Initial commit

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/.gitattributes

@@ -0,0 +1,96 @@
+* 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

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/.travis.yml

@@ -0,0 +1,324 @@
+# Copyright 2016, 2017 Peter Dimov
+# 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)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    #- os: linux
+    #  compiler: clang++-3.8
+    #  env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.8
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.8
+
+    #- os: linux
+    #  compiler: clang++-3.8
+    #  env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.8
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    #- os: linux
+    #  compiler: clang++-3.9
+    #  env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.9
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.9
+
+    #- os: linux
+    #  compiler: clang++-3.9
+    #  env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.9
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_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 tools/boostdep
+  - mkdir -p libs/ratio
+  - cp -r $TRAVIS_BUILD_DIR/* libs/ratio
+  - python tools/boostdep/depinst/depinst.py ratio
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/ratio/test toolset=$TOOLSET
+  #- mkdir __build__ && cd __build__
+  #- export CXX=$COMPILER
+  #- cmake -DBOOST_RATIO_INCLUDE_TESTS=ON ../libs/ratio/test/test_cmake
+  #- cmake --build .
+  #- ctest .
+
+notifications:
+  email:
+    on_success: always

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/CMakeLists.txt

@@ -0,0 +1,31 @@
+# Generated by `boostdep --cmake ratio`
+# Copyright 2020 Peter Dimov
+# 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_ratio VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_ratio INTERFACE)
+add_library(Boost::ratio ALIAS boost_ratio)
+
+target_include_directories(boost_ratio INTERFACE include)
+
+target_link_libraries(boost_ratio
+  INTERFACE
+    Boost::config
+    Boost::core
+    Boost::integer
+    Boost::mpl
+    Boost::rational
+    Boost::static_assert
+    Boost::type_traits
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/README.md

@@ -0,0 +1,8 @@
+ratio
+======
+
+Compile time rational arithmetic. C++11.
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/appveyor.yml

@@ -0,0 +1,46 @@
+# Copyright 2016, 2017 Peter Dimov
+# 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_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 tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\ratio\
+  - python tools/boostdep/depinst/depinst.py ratio
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/ratio/test toolset=%TOOLSET%
+  - mkdir __build__
+  - cd __build__
+  - cmake -DBOOST_RATIO_INCLUDE_TESTS=ON ../libs/ratio/test/test_cmake
+  - cmake --build .
+  - ctest .

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/doc/Jamfile.v2

@@ -0,0 +1,86 @@
+#  Boost.Ratio library documentation Jamfile  ---------------------------------
+#
+#  Copyright Vicente J. Botet Escriba 2010. 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)
+#
+#  See http://www.boost.org for updates, documentation, and revision history.
+
+#import doxygen ;
+import quickbook ;
+
+#doxygen autodoc
+#   :
+#      [ glob ../../../boost/chrono/*.hpp ]
+#      [ glob ../../../boost/chrono/allocators/*.hpp ]
+#   :
+#        <doxygen:param>EXTRACT_ALL=NO
+#        <doxygen:param>HIDE_UNDOC_MEMBERS=YES
+#        <doxygen:param>EXTRACT_PRIVATE=NO
+#        <doxygen:param>EXPAND_ONLY_PREDEF=YES
+#        <doxygen:param>PREDEFINED=BOOST_INTERPROCESS_DOXYGEN_INVOKED
+#        <xsl:param>"boost.doxygen.reftitle=Boost.Chrono Reference"
+#   ;
+
+xml ratio : ratio.qbk ;
+
+boostbook standalone
+   :
+      ratio
+   :
+        # 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=0
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=1
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=4
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=2
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=10
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+        # Path for libraries index:
+        <xsl:param>boost.libraries=../../../../libs/libraries.htm
+        # Use the main Boost stylesheet:
+        <xsl:param>html.stylesheet=../../../../doc/src/boostbook.css
+
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        # Or enable this if you're using XEP:
+        <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!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/ratio/doc/html
+   ;
+
+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
+explicit pdfinstall ;
+
+###############################################################################
+alias boostdoc
+    : ratio
+    :
+    : #<dependency>autodoc
+    : ;
+explicit boostdoc ;
+alias boostrelease ;
+explicit boostrelease ;

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/config.hpp

@@ -0,0 +1,123 @@
+//  boost/chrono/config.hpp  -------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2006, 2008
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the 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/chrono for documentation.
+
+#ifndef BOOST_EX_CHRONO_CONFIG_HPP
+#define BOOST_EX_CHRONO_CONFIG_HPP
+
+#include <boost/config.hpp>
+
+//  BOOST_EX_CHRONO_POSIX_API, BOOST_EX_CHRONO_MAC_API, or BOOST_EX_CHRONO_WINDOWS_API
+//  can be defined by the user to specify which API should be used
+
+#if defined(BOOST_EX_CHRONO_WINDOWS_API)
+# warning Boost.Chrono will use the Windows API
+#elif defined(BOOST_EX_CHRONO_MAC_API)
+# warning Boost.Chrono will use the Mac API
+#elif defined(BOOST_EX_CHRONO_POSIX_API)
+# warning Boost.Chrono will use the POSIX API
+#endif
+
+# if defined( BOOST_EX_CHRONO_WINDOWS_API ) && defined( BOOST_EX_CHRONO_POSIX_API )
+#   error both BOOST_EX_CHRONO_WINDOWS_API and BOOST_EX_CHRONO_POSIX_API are defined
+# elif defined( BOOST_EX_CHRONO_WINDOWS_API ) && defined( BOOST_EX_CHRONO_MAC_API )
+#   error both BOOST_EX_CHRONO_WINDOWS_API and BOOST_EX_CHRONO_MAC_API are defined
+# elif defined( BOOST_EX_CHRONO_MAC_API ) && defined( BOOST_EX_CHRONO_POSIX_API )
+#   error both BOOST_EX_CHRONO_MAC_API and BOOST_EX_CHRONO_POSIX_API are defined
+# elif !defined( BOOST_EX_CHRONO_WINDOWS_API ) && !defined( BOOST_EX_CHRONO_MAC_API ) && !defined( BOOST_EX_CHRONO_POSIX_API )
+#   if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+#     define BOOST_EX_CHRONO_WINDOWS_API
+#     define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
+#     define BOOST_EX_CHRONO_HAS_THREAD_CLOCK
+#     define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+#   elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+#     define BOOST_EX_CHRONO_MAC_API
+#     define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
+#     define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+#   else
+#     define BOOST_EX_CHRONO_POSIX_API
+#   endif
+# endif
+
+# if defined( BOOST_EX_CHRONO_POSIX_API )
+#   include <time.h>  //to check for CLOCK_REALTIME and CLOCK_MONOTONIC and _POSIX_THREAD_CPUTIME
+#   if defined(CLOCK_REALTIME)
+#     if defined(CLOCK_MONOTONIC)
+#        define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
+#     endif
+#   else
+#     error <time.h> does not supply CLOCK_REALTIME
+#   endif
+#   if defined(_POSIX_THREAD_CPUTIME)
+#     define BOOST_EX_CHRONO_HAS_THREAD_CLOCK
+#     define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+#   endif
+# endif
+
+
+
+//  enable dynamic linking on Windows  ---------------------------------------//
+
+//#  if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
+//#    error Dynamic linking Boost.System does not work for Borland; use static linking instead
+//#  endif
+
+#ifdef BOOST_HAS_DECLSPEC // defined by boost.config
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_EX_CHRONO_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)
+// export if this is our own source, otherwise import:
+#ifdef BOOST_EX_CHRONO_SOURCE
+# define BOOST_EX_CHRONO_DECL __declspec(dllexport)
+#else
+# define BOOST_EX_CHRONO_DECL __declspec(dllimport)
+#endif  // BOOST_EX_CHRONO_SOURCE
+#endif  // DYN_LINK
+#endif  // BOOST_HAS_DECLSPEC
+//
+// if BOOST_EX_CHRONO_DECL isn't defined yet define it now:
+#ifndef BOOST_EX_CHRONO_DECL
+#define BOOST_EX_CHRONO_DECL
+#endif
+
+//  define constexpr related macros  ------------------------------//
+
+//~ #include <boost/config.hpp>
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#define BOOST_EX_CHRONO_CONSTEXPR
+#define BOOST_EX_CHRONO_CONST_REF const&
+#else
+#define BOOST_EX_CHRONO_CONSTEXPR constexpr
+#define BOOST_EX_CHRONO_CONST_REF
+#endif
+
+//  enable automatic library variant selection  ------------------------------//
+
+#if !defined(BOOST_EX_CHRONO_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_EX_CHRONO_NO_LIB) && !defined(BOOST_CHRONO_NO_LIB)
+//
+// Set the name of our library; this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_chrono
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_EX_CHRONO_CONFIG_HPP
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/display_ex.cpp

@@ -0,0 +1,39 @@
+//  io_ex2.cpp  ----------------------------------------------------------//
+
+//  Copyright 2010 Howard Hinnant
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+This code was adapted by Vicente J. Botet Escriba from Hinnant's html documentation.
+Many thanks to Howard for making his code available under the Boost license.
+*/
+
+#include <iostream>
+#include <boost/ratio/ratio_io.hpp>
+
+int main()
+{
+    using namespace std;
+    using namespace boost;
+
+    cout << "ratio_string<deca, char>::prefix() = "
+             <<  ratio_string<boost::deca, char>::prefix() << '\n';
+    cout << "ratio_string<deca, char>::symbol() = "
+             <<  ratio_string<boost::deca, char>::symbol() << '\n';
+
+    cout << "ratio_string<giga, char>::prefix() = "
+             <<  ratio_string<boost::giga, char>::prefix() << '\n';
+    cout << "ratio_string<giga, char>::symbol() = "
+             <<  ratio_string<boost::giga, char>::symbol() << '\n';
+
+    cout << "ratio_string<ratio<4, 6>, char>::prefix() = "
+             <<  ratio_string<boost::ratio<4, 6>, char>::prefix() << '\n';
+    cout << "ratio_string<ratio<4, 6>, char>::symbol() = "
+             <<  ratio_string<boost::ratio<4, 6>, char>::symbol() << '\n';
+
+    return 0;
+}
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/duration.hpp

@@ -0,0 +1,799 @@
+//  duration.hpp  --------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+
+This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
+Many thanks to Howard for making his code available under the Boost license.
+The original code was modified to conform to Boost conventions and to section
+20.9 Time utilities [time] of the C++ committee's working paper N2798.
+See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
+
+time2_demo contained this comment:
+
+    Much thanks to Andrei Alexandrescu,
+                   Walter Brown,
+                   Peter Dimov,
+                   Jeff Garland,
+                   Terry Golubiewski,
+                   Daniel Krugler,
+                   Anthony Williams.
+*/
+
+
+#ifndef BOOST_EX_CHRONO_DURATION_HPP
+#define BOOST_EX_CHRONO_DURATION_HPP
+
+#include "config.hpp"
+#include "static_assert.hpp"
+
+//~ #include <iostream>
+
+#include <climits>
+#include <limits>
+
+
+#include <boost/mpl/logical.hpp>
+#include <boost/ratio/ratio.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+#include <boost/cstdint.hpp>
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+#else
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/detail/workaround.hpp>
+#include <boost/integer_traits.hpp>
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_EX_CHRONO_USES_MPL_ASSERT)
+#define BOOST_EX_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION        "A duration representation can not be a duration"
+#define BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio"
+#define BOOST_EX_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive"
+#define BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_EX_CHRONO_DURATION "Second template parameter of time_point must be a boost_ex::chrono::duration"
+#endif
+
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                        20.9 Time utilities [time]                          //
+//                                 synopsis                                   //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+    using boost::ratio;
+
+namespace chrono {
+
+  template <class Rep, class Period = ratio<1> >
+    class duration;
+
+    namespace detail
+    {
+    template <class T>
+      struct is_duration
+        : boost::false_type {};
+
+    template <class Rep, class Period>
+      struct is_duration<duration<Rep, Period> >
+        : boost::true_type  {};
+    //template <class T>
+    //  struct is_duration
+    //    : is_duration<typename boost::remove_cv<T>::type> {};
+
+    template <class Duration, class Rep, bool = is_duration<Rep>::value>
+    struct duration_divide_result
+    {
+    };
+
+    template <class Duration, class Rep2,
+        bool = (
+                    (boost::is_convertible<typename Duration::rep,
+                        typename boost::common_type<typename Duration::rep, Rep2>::type>::value)
+                &&  (boost::is_convertible<Rep2,
+                        typename boost::common_type<typename Duration::rep, Rep2>::type>::value)
+                )
+        >
+    struct duration_divide_imp
+    {
+    };
+
+    template <class Rep1, class Period, class Rep2>
+    struct duration_divide_imp<duration<Rep1, Period>, Rep2, true>
+    {
+        typedef duration<typename boost::common_type<Rep1, Rep2>::type, Period> type;
+    };
+
+    template <class Rep1, class Period, class Rep2>
+    struct duration_divide_result<duration<Rep1, Period>, Rep2, false>
+        : duration_divide_imp<duration<Rep1, Period>, Rep2>
+    {
+    };
+
+///
+    template <class Rep, class Duration, bool = is_duration<Rep>::value>
+    struct duration_divide_result2
+    {
+    };
+
+    template <class Rep, class Duration,
+        bool = (
+                    (boost::is_convertible<typename Duration::rep,
+                        typename boost::common_type<typename Duration::rep, Rep>::type>::value)
+                &&  (boost::is_convertible<Rep,
+                        typename boost::common_type<typename Duration::rep, Rep>::type>::value)
+                )
+        >
+    struct duration_divide_imp2
+    {
+    };
+
+    template <class Rep1, class Rep2, class Period >
+    struct duration_divide_imp2<Rep1, duration<Rep2, Period>, true>
+    {
+        //typedef typename boost::common_type<Rep1, Rep2>::type type;
+        typedef double type;
+    };
+
+    template <class Rep1, class Rep2, class Period >
+    struct duration_divide_result2<Rep1, duration<Rep2, Period>, false>
+        : duration_divide_imp2<Rep1, duration<Rep2, Period> >
+    {
+    };
+
+///
+    template <class Duration, class Rep, bool = is_duration<Rep>::value>
+    struct duration_modulo_result
+    {
+    };
+
+    template <class Duration, class Rep2,
+        bool = (
+                    //boost::is_convertible<typename Duration::rep,
+                        //typename boost::common_type<typename Duration::rep, Rep2>::type>::value
+                //&&
+    boost::is_convertible<Rep2,
+                        typename boost::common_type<typename Duration::rep, Rep2>::type>::value
+                )
+        >
+    struct duration_modulo_imp
+    {
+    };
+
+    template <class Rep1, class Period, class Rep2>
+    struct duration_modulo_imp<duration<Rep1, Period>, Rep2, true>
+    {
+        typedef duration<typename boost::common_type<Rep1, Rep2>::type, Period> type;
+    };
+
+    template <class Rep1, class Period, class Rep2>
+    struct duration_modulo_result<duration<Rep1, Period>, Rep2, false>
+        : duration_modulo_imp<duration<Rep1, Period>, Rep2>
+    {
+    };
+
+  } // namespace detail
+} // namespace chrono
+}
+
+namespace boost {
+// common_type trait specializations
+
+template <class Rep1, class Period1, class Rep2, class Period2>
+  struct common_type<boost_ex::chrono::duration<Rep1, Period1>,
+                     boost_ex::chrono::duration<Rep2, Period2> >;
+
+}
+namespace boost_ex {
+
+namespace chrono {
+
+  // customization traits
+  template <class Rep> struct treat_as_floating_point;
+  template <class Rep> struct duration_values;
+
+  // duration arithmetic
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+//    operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+//    operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period, class Rep2>
+//    typename boost::enable_if_c
+//    <
+//      boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>::value
+//        && boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>::value,
+//      duration<typename common_type<Rep1, Rep2>::type, Period>
+//    >::type
+//   operator*(const duration<Rep1, Period>& d, const Rep2& s);
+//  template <class Rep1, class Period, class Rep2>
+//    typename boost::enable_if_c
+//    <
+//      boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>::value
+//        && boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>::value,
+//      duration<typename common_type<Rep1, Rep2>::type, Period>
+//    >::type
+//    operator*(const Rep1& s, const duration<Rep2, Period>& d);
+
+//  template <class Rep1, class Period, class Rep2>
+//    typename boost::disable_if <detail::is_duration<Rep2>,
+//      typename detail::duration_divide_result<duration<Rep1, Period>, Rep2>::type
+//    >::type
+//    operator/(const duration<Rep1, Period>& d, const Rep2& s);
+
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    typename common_type<Rep1, Rep2>::type
+//    operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+  // duration comparisons
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+//  template <class Rep1, class Period1, class Rep2, class Period2>
+//    bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+  // duration_cast
+
+  //template <class ToDuration, class Rep, class Period>
+  //  ToDuration duration_cast(const duration<Rep, Period>& d);
+
+  // convenience typedefs
+  typedef duration<boost::int_least64_t, boost::nano> nanoseconds;    // at least 64 bits needed
+  typedef duration<boost::int_least64_t, boost::micro> microseconds;  // at least 55 bits needed
+  typedef duration<boost::int_least64_t, boost::milli> milliseconds;  // at least 45 bits needed
+  typedef duration<boost::int_least64_t> seconds;              // at least 35 bits needed
+  typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
+  typedef duration<boost::int_least32_t, ratio<3600> > hours;  // at least 23 bits needed
+
+//----------------------------------------------------------------------------//
+//                          duration helpers                                  //
+//----------------------------------------------------------------------------//
+
+  namespace detail
+  {
+
+    // duration_cast
+
+    // duration_cast is the heart of this whole prototype.  It can convert any
+    //   duration to any other.  It is also (implicitly) used in converting
+    //   time_points.  The conversion is always exact if possible.  And it is
+    //   always as efficient as hand written code.  If different representations
+    //   are involved, care is taken to never require implicit conversions.
+    //   Instead static_cast is used explicitly for every required conversion.
+    //   If there are a mixture of integral and floating point representations,
+    //   the use of common_type ensures that the most logical "intermediate"
+    //   representation is used.
+    template <class FromDuration, class ToDuration,
+              class Period = typename boost::ratio_divide<typename FromDuration::period,
+              typename ToDuration::period>::type,
+              bool = Period::num == 1,
+              bool = Period::den == 1>
+    struct duration_cast;
+
+    // When the two periods are the same, all that is left to do is static_cast from
+    //   the source representation to the target representation (which may be a no-op).
+    //   This conversion is always exact as long as the static_cast from the source
+    //   representation to the destination representation is exact.
+    template <class FromDuration, class ToDuration, class Period>
+    struct duration_cast<FromDuration, ToDuration, Period, true, true>
+    {
+        ToDuration operator()(const FromDuration& fd) const
+        {
+            return ToDuration(static_cast<typename ToDuration::rep>(fd.count()));
+        }
+    };
+
+    // When the numerator of FromPeriod / ToPeriod is 1, then all we need to do is
+    //   divide by the denominator of FromPeriod / ToPeriod.  The common_type of
+    //   the two representations is used for the intermediate computation before
+    //   static_cast'ing to the destination.
+    //   This conversion is generally not exact because of the division (but could be
+    //   if you get lucky on the run time value of fd.count()).
+    template <class FromDuration, class ToDuration, class Period>
+    struct duration_cast<FromDuration, ToDuration, Period, true, false>
+    {
+        ToDuration operator()(const FromDuration& fd) const
+        {
+            typedef typename boost::common_type<
+                typename ToDuration::rep,
+                typename FromDuration::rep,
+                boost::intmax_t>::type C;
+            return ToDuration(static_cast<typename ToDuration::rep>(
+                              static_cast<C>(fd.count()) / static_cast<C>(Period::den)));
+        }
+    };
+
+    // When the denomenator of FromPeriod / ToPeriod is 1, then all we need to do is
+    //   multiply by the numerator of FromPeriod / ToPeriod.  The common_type of
+    //   the two representations is used for the intermediate computation before
+    //   static_cast'ing to the destination.
+    //   This conversion is always exact as long as the static_cast's involved are exact.
+    template <class FromDuration, class ToDuration, class Period>
+    struct duration_cast<FromDuration, ToDuration, Period, false, true>
+    {
+        ToDuration operator()(const FromDuration& fd) const
+        {
+            typedef typename boost::common_type<
+              typename ToDuration::rep,
+              typename FromDuration::rep,
+              boost::intmax_t>::type C;
+            return ToDuration(static_cast<typename ToDuration::rep>(
+                              static_cast<C>(fd.count()) * static_cast<C>(Period::num)));
+        }
+    };
+
+    // When neither the numerator or denominator of FromPeriod / ToPeriod is 1, then we need to
+    //   multiply by the numerator and divide by the denominator of FromPeriod / ToPeriod.  The
+    //   common_type of the two representations is used for the intermediate computation before
+    //   static_cast'ing to the destination.
+    //   This conversion is generally not exact because of the division (but could be
+    //   if you get lucky on the run time value of fd.count()).
+    template <class FromDuration, class ToDuration, class Period>
+    struct duration_cast<FromDuration, ToDuration, Period, false, false>
+    {
+        ToDuration operator()(const FromDuration& fd) const
+        {
+            typedef typename boost::common_type<
+              typename ToDuration::rep,
+              typename FromDuration::rep,
+              boost::intmax_t>::type C;
+            return ToDuration(static_cast<typename ToDuration::rep>(
+               static_cast<C>(fd.count()) * static_cast<C>(Period::num)
+                 / static_cast<C>(Period::den)));
+        }
+    };
+
+  } // namespace detail
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//      20.9.2 Time-related traits [time.traits]                              //
+//                                                                            //
+//----------------------------------------------------------------------------//
+//----------------------------------------------------------------------------//
+//      20.9.2.1 treat_as_floating_point [time.traits.is_fp]                        //
+//      Probably should have been treat_as_floating_point. Editor notifed.    //
+//----------------------------------------------------------------------------//
+
+  // Support bidirectional (non-exact) conversions for floating point rep types
+  //   (or user defined rep types which specialize treat_as_floating_point).
+  template <class Rep>
+    struct treat_as_floating_point : boost::is_floating_point<Rep> {};
+
+//----------------------------------------------------------------------------//
+//      20.9.2.2 duration_values [time.traits.duration_values]                //
+//----------------------------------------------------------------------------//
+
+  namespace detail {
+    template <class T, bool = boost::is_arithmetic<T>::value>
+    struct chrono_numeric_limits {
+        static T lowest() throw() {return (std::numeric_limits<T>::min)  ();}
+    };
+
+    template <class T>
+    struct chrono_numeric_limits<T,true> {
+        static T lowest() throw() {return (std::numeric_limits<T>::min)  ();}
+    };
+
+    template <>
+    struct chrono_numeric_limits<float,true> {
+        static float lowest() throw() {return -(std::numeric_limits<float>::max) ();}
+    };
+
+    template <>
+    struct chrono_numeric_limits<double,true> {
+        static double lowest() throw() {return -(std::numeric_limits<double>::max) ();}
+    };
+
+    template <>
+    struct chrono_numeric_limits<long double,true> {
+        static long double lowest() throw() {return -(std::numeric_limits<long double>::max)();}
+    };
+
+    template <class T>
+    struct numeric_limits : chrono_numeric_limits<typename boost::remove_cv<T>::type> {};
+
+  }
+  template <class Rep>
+  struct duration_values
+  {
+      static  Rep zero() {return Rep(0);}
+      static  Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()  {return (std::numeric_limits<Rep>::max)();}
+
+      static  Rep min BOOST_PREVENT_MACRO_SUBSTITUTION ()  {return detail::numeric_limits<Rep>::lowest();}
+  };
+
+}  // namespace chrono
+}
+//----------------------------------------------------------------------------//
+//      20.9.2.3 Specializations of common_type [time.traits.specializations] //
+//----------------------------------------------------------------------------//
+namespace boost {
+template <class Rep1, class Period1, class Rep2, class Period2>
+struct common_type<boost_ex::chrono::duration<Rep1, Period1>,
+                   boost_ex::chrono::duration<Rep2, Period2> >
+{
+  typedef boost_ex::chrono::duration<typename common_type<Rep1, Rep2>::type,
+                      typename boost::ratio_gcd<Period1, Period2>::type> type;
+};
+
+}
+//----------------------------------------------------------------------------//
+//                                                                            //
+//         20.9.3 Class template duration [time.duration]                     //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+namespace chrono {
+
+    template <class Rep, class Period>
+    class duration
+    {
+    BOOST_EX_CHRONO_STATIC_ASSERT(!boost_ex::chrono::detail::is_duration<Rep>::value, BOOST_EX_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION, ());
+    BOOST_EX_CHRONO_STATIC_ASSERT(boost::ratio_detail::is_ratio<Period>::value, BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO, ());
+    BOOST_EX_CHRONO_STATIC_ASSERT(Period::num>0, BOOST_EX_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE, ());
+    public:
+        typedef Rep rep;
+        typedef Period period;
+    private:
+        rep rep_;
+    public:
+
+         duration() { } // = default;
+        template <class Rep2>
+         explicit duration(const Rep2& r
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+#else
+   , typename boost::enable_if <
+                    boost::mpl::and_ <
+                        boost::is_convertible<Rep2, rep>,
+                        boost::mpl::or_ <
+                            treat_as_floating_point<rep>,
+                            boost::mpl::and_ <
+                                boost::mpl::not_ < treat_as_floating_point<rep> >,
+                                boost::mpl::not_ < treat_as_floating_point<Rep2> >
+                            >
+                        >
+                    >
+                >::type* = 0
+#endif
+   )
+                  : rep_(r) { }
+        ~duration() {} //= default;
+        duration(const duration& rhs) : rep_(rhs.rep_) {} // = default;
+        duration& operator=(const duration& rhs) // = default;
+        {
+            if (&rhs != this) rep_= rhs.rep_;
+            return *this;
+        }
+
+        // conversions
+        template <class Rep2, class Period2>
+         duration(const duration<Rep2, Period2>& d
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+#else
+    , typename boost::enable_if <
+                    boost::mpl::or_ <
+                        treat_as_floating_point<rep>,
+                        boost::mpl::and_ <
+                            boost::mpl::bool_ < boost::ratio_divide<Period2, period>::type::den == 1>,
+                            boost::mpl::not_ < treat_as_floating_point<Rep2> >
+                        >
+                    >
+                >::type* = 0
+#endif
+    )
+//~ #ifdef        __GNUC__
+            // GCC 4.2.4 refused to accept a definition at this point,
+            // yet both VC++ 9.0 SP1 and Intel ia32 11.0 accepted the definition
+            // without complaint. VC++ 9.0 SP1 refused to accept a later definition,
+            // although that was fine with GCC 4.2.4 and Intel ia32 11.0. Thus we
+            // have to support both approaches.
+            //~ ;
+//~ #else
+            //~ : rep_(chrono::duration_cast<duration>(d).count()) {}
+            : rep_(chrono::detail::duration_cast<duration<Rep2, Period2>, duration>()(d).count()) {}
+//~ #endif
+
+        // observer
+
+         rep count() const {return rep_;}
+
+        // arithmetic
+
+        duration  operator+() const {return *this;}
+        duration  operator-() const {return duration(-rep_);}
+        duration& operator++()      {++rep_; return *this;}
+        duration  operator++(int)   {return duration(rep_++);}
+        duration& operator--()      {--rep_; return *this;}
+        duration  operator--(int)   {return duration(rep_--);}
+
+        duration& operator+=(const duration& d) {rep_ += d.count(); return *this;}
+        duration& operator-=(const duration& d) {rep_ -= d.count(); return *this;}
+
+        duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;}
+        duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;}
+        duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;}
+        duration& operator%=(const duration& rhs) {rep_ %= rhs.count(); return *this;};
+        // 20.9.3.4 duration special values [time.duration.special]
+
+        static  duration zero() {return duration(duration_values<rep>::zero());}
+        static  duration min BOOST_PREVENT_MACRO_SUBSTITUTION ()  {return duration((duration_values<rep>::min)());}
+        static  duration max BOOST_PREVENT_MACRO_SUBSTITUTION ()  {return duration((duration_values<rep>::max)());}
+    };
+
+//----------------------------------------------------------------------------//
+//      20.9.3.5 duration non-member arithmetic [time.duration.nonmember]     //
+//----------------------------------------------------------------------------//
+
+  // Duration +
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  typename boost::common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+  operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      typename boost::common_type<duration<Rep1, Period1>,
+        duration<Rep2, Period2> >::type result = lhs;
+      result += rhs;
+      return result;
+  }
+
+  // Duration -
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  typename boost::common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+  operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      typename boost::common_type<duration<Rep1, Period1>,
+        duration<Rep2, Period2> >::type result = lhs;
+      result -= rhs;
+      return result;
+  }
+
+  // Duration *
+
+  template <class Rep1, class Period, class Rep2>
+  inline
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+    duration<typename boost::common_type<Rep1, Rep2>::type, Period>
+#else
+typename boost::enable_if <
+    boost::mpl::and_ <
+        boost::is_convertible<Rep1, typename boost::common_type<Rep1, Rep2>::type>,
+        boost::is_convertible<Rep2, typename boost::common_type<Rep1, Rep2>::type>
+    >,
+    duration<typename boost::common_type<Rep1, Rep2>::type, Period>
+  >::type
+#endif
+  operator*(const duration<Rep1, Period>& d, const Rep2& s)
+  {
+      typedef typename boost::common_type<Rep1, Rep2>::type CR;
+      duration<CR, Period> r = d;
+      r *= static_cast<CR>(s);
+      return r;
+  }
+
+  template <class Rep1, class Period, class Rep2>
+  inline
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+    duration<typename boost::common_type<Rep1, Rep2>::type, Period>
+#else
+  typename boost::enable_if <
+    boost::mpl::and_ <
+        boost::is_convertible<Rep1, typename boost::common_type<Rep1, Rep2>::type>,
+        boost::is_convertible<Rep2, typename boost::common_type<Rep1, Rep2>::type>
+    >,
+    duration<typename boost::common_type<Rep1, Rep2>::type, Period>
+  >::type
+#endif
+  operator*(const Rep1& s, const duration<Rep2, Period>& d)
+  {
+      return d * s;
+  }
+
+  // Duration /
+
+  template <class Rep1, class Period, class Rep2>
+  inline
+  typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep2>,
+    typename boost_ex::chrono::detail::duration_divide_result<duration<Rep1, Period>, Rep2>::type
+  >::type
+  operator/(const duration<Rep1, Period>& d, const Rep2& s)
+  {
+      typedef typename boost::common_type<Rep1, Rep2>::type CR;
+      duration<CR, Period> r = d;
+      r /= static_cast<CR>(s);
+      return r;
+  }
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  typename boost::common_type<Rep1, Rep2>::type
+  operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      typedef typename boost::common_type<duration<Rep1, Period1>,
+                                   duration<Rep2, Period2> >::type CD;
+      return CD(lhs).count() / CD(rhs).count();
+  }
+
+  template <class Rep1, class Rep2, class Period>
+  inline
+  typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep1>,
+    typename boost_ex::chrono::detail::duration_divide_result2<Rep1, duration<Rep2, Period> >::type
+  >::type
+  operator/(const Rep1& s, const duration<Rep2, Period>& d)
+  {
+      typedef typename boost::common_type<Rep1, Rep2>::type CR;
+      duration<CR, Period> r = d;
+      //return static_cast<CR>(r.count()) / static_cast<CR>(s);
+      return  static_cast<CR>(s)/r.count();
+  }
+
+  // Duration %
+
+  template <class Rep1, class Period, class Rep2>
+  typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep2>,
+    typename boost_ex::chrono::detail::duration_modulo_result<duration<Rep1, Period>, Rep2>::type
+  >::type
+  operator%(const duration<Rep1, Period>& d, const Rep2& s) {
+    typedef typename boost::common_type<Rep1, Rep2>::type CR;
+    duration<CR, Period> r = d;
+    r %= static_cast<CR>(s);
+    return r;
+  }
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  typename boost::common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+  operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
+    typedef typename boost::common_type<duration<Rep1, Period1>,
+                                 duration<Rep2, Period2> >::type CD;
+    CD r(lhs);
+    r%=CD(rhs);
+    return r;
+  }
+
+
+//----------------------------------------------------------------------------//
+//      20.9.3.6 duration comparisons [time.duration.comparisons]             //
+//----------------------------------------------------------------------------//
+
+  namespace detail
+  {
+    template <class LhsDuration, class RhsDuration>
+    struct duration_eq
+    {
+        bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
+            {
+                typedef typename boost::common_type<LhsDuration, RhsDuration>::type CD;
+                return CD(lhs).count() == CD(rhs).count();
+            }
+    };
+
+    template <class LhsDuration>
+    struct duration_eq<LhsDuration, LhsDuration>
+    {
+        bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
+            {return lhs.count() == rhs.count();}
+    };
+
+    template <class LhsDuration, class RhsDuration>
+    struct duration_lt
+    {
+        bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
+            {
+                typedef typename boost::common_type<LhsDuration, RhsDuration>::type CD;
+                return CD(lhs).count() < CD(rhs).count();
+            }
+    };
+
+    template <class LhsDuration>
+    struct duration_lt<LhsDuration, LhsDuration>
+    {
+        bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
+            {return lhs.count() < rhs.count();}
+    };
+
+  } // namespace detail
+
+  // Duration ==
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return boost_ex::chrono::detail::duration_eq<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
+  }
+
+  // Duration !=
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return !(lhs == rhs);
+  }
+
+  // Duration <
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return boost_ex::chrono::detail::duration_lt<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
+  }
+
+  // Duration >
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return rhs < lhs;
+  }
+
+  // Duration <=
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return !(rhs < lhs);
+  }
+
+  // Duration >=
+
+  template <class Rep1, class Period1, class Rep2, class Period2>
+  inline
+  bool
+  operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
+  {
+      return !(lhs < rhs);
+  }
+
+//----------------------------------------------------------------------------//
+//      20.9.3.7 duration_cast [time.duration.cast]                           //
+//----------------------------------------------------------------------------//
+
+  // Compile-time select the most efficient algorithm for the conversion...
+  template <class ToDuration, class Rep, class Period>
+  inline
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1500)) || defined(__IBMCPP__)
+    ToDuration
+#else
+  typename boost::enable_if <boost_ex::chrono::detail::is_duration<ToDuration>, ToDuration>::type
+#endif
+  duration_cast(const duration<Rep, Period>& fd)
+  {
+      return boost_ex::chrono::detail::duration_cast<duration<Rep, Period>, ToDuration>()(fd);
+  }
+
+}
+}
+#endif // BOOST_EX_CHRONO_DURATION_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/si_physics.cpp

@@ -0,0 +1,236 @@
+//  ratio_test.cpp  ----------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <iostream>
+#include <boost/ratio/ratio.hpp>
+#include "duration.hpp"
+
+namespace User1
+{
+// Example type-safe "physics" code interoperating with chrono::duration types
+//  and taking advantage of the std::ratio infrastructure and design philosophy.
+
+// length - mimics chrono::duration except restricts representation to double.
+//    Uses boost::ratio facilities for length units conversions.
+
+template <class Ratio>
+class length
+{
+public:
+    typedef Ratio ratio;
+private:
+    double len_;
+public:
+
+    length() : len_(1) {}
+    length(const double& len) : len_(len) {}
+
+    // conversions
+    template <class R>
+    length(const length<R>& d)
+            : len_(d.count() * boost::ratio_divide<Ratio, R>::type::den /
+                               boost::ratio_divide<Ratio, R>::type::num) {}
+
+    // observer
+
+    double count() const {return len_;}
+
+    // arithmetic
+
+    length& operator+=(const length& d) {len_ += d.count(); return *this;}
+    length& operator-=(const length& d) {len_ -= d.count(); return *this;}
+
+    length operator+() const {return *this;}
+    length operator-() const {return length(-len_);}
+
+    length& operator*=(double rhs) {len_ *= rhs; return *this;}
+    length& operator/=(double rhs) {len_ /= rhs; return *this;}
+};
+
+// Sparse sampling of length units
+typedef length<boost::ratio<1> >          meter;        // set meter as "unity"
+typedef length<boost::centi>              centimeter;   // 1/100 meter
+typedef length<boost::kilo>               kilometer;    // 1000  meters
+typedef length<boost::ratio<254, 10000> > inch;         // 254/10000 meters
+// length takes ratio instead of two integral types so that definitions can be made like so:
+typedef length<boost::ratio_multiply<boost::ratio<12>, inch::ratio>::type>   foot;  // 12 inchs
+typedef length<boost::ratio_multiply<boost::ratio<5280>, foot::ratio>::type> mile;  // 5280 feet
+
+// Need a floating point definition of seconds
+typedef boost_ex::chrono::duration<double> seconds;                         // unity
+// Demo of (scientific) support for sub-nanosecond resolutions
+typedef boost_ex::chrono::duration<double,  boost::pico> picosecond;  // 10^-12 seconds
+typedef boost_ex::chrono::duration<double, boost::femto> femtosecond; // 10^-15 seconds
+typedef boost_ex::chrono::duration<double,  boost::atto> attosecond;  // 10^-18 seconds
+
+// A very brief proof-of-concept for SIUnits-like library
+//  Hard-wired to floating point seconds and meters, but accepts other units (shown in testUser1())
+template <class R1, class R2>
+class quantity
+{
+    double q_;
+public:
+    typedef R1 time_dim;
+    typedef R2 distance_dim;
+    quantity() : q_(1) {}
+
+    double get() const {return q_;}
+    void set(double q) {q_ = q;}
+};
+
+template <>
+class quantity<boost::ratio<1>, boost::ratio<0> >
+{
+    double q_;
+public:
+    quantity() : q_(1) {}
+    quantity(seconds d) : q_(d.count()) {}  // note:  only User1::seconds needed here
+
+    double get() const {return q_;}
+    void set(double q) {q_ = q;}
+};
+
+template <>
+class quantity<boost::ratio<0>, boost::ratio<1> >
+{
+    double q_;
+public:
+    quantity() : q_(1) {}
+    quantity(meter d) : q_(d.count()) {}  // note:  only User1::meter needed here
+
+    double get() const {return q_;}
+    void set(double q) {q_ = q;}
+};
+
+template <>
+class quantity<boost::ratio<0>, boost::ratio<0> >
+{
+    double q_;
+public:
+    quantity() : q_(1) {}
+    quantity(double d) : q_(d) {}
+
+    double get() const {return q_;}
+    void set(double q) {q_ = q;}
+};
+
+// Example SI-Units
+typedef quantity<boost::ratio<0>, boost::ratio<0> >  Scalar;
+typedef quantity<boost::ratio<1>, boost::ratio<0> >  Time;         // second
+typedef quantity<boost::ratio<0>, boost::ratio<1> >  Distance;     // meter
+typedef quantity<boost::ratio<-1>, boost::ratio<1> > Speed;        // meter/second
+typedef quantity<boost::ratio<-2>, boost::ratio<1> > Acceleration; // meter/second^2
+
+template <class R1, class R2, class R3, class R4>
+quantity<typename boost::ratio_subtract<R1, R3>::type, typename boost::ratio_subtract<R2, R4>::type>
+operator/(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
+{
+    typedef quantity<typename boost::ratio_subtract<R1, R3>::type, typename boost::ratio_subtract<R2, R4>::type> R;
+    R r;
+    r.set(x.get() / y.get());
+    return r;
+}
+
+template <class R1, class R2, class R3, class R4>
+quantity<typename boost::ratio_add<R1, R3>::type, typename boost::ratio_add<R2, R4>::type>
+operator*(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
+{
+    typedef quantity<typename boost::ratio_add<R1, R3>::type, typename boost::ratio_add<R2, R4>::type> R;
+    R r;
+    r.set(x.get() * y.get());
+    return r;
+}
+
+template <class R1, class R2>
+quantity<R1, R2>
+operator+(const quantity<R1, R2>& x, const quantity<R1, R2>& y)
+{
+    typedef quantity<R1, R2> R;
+    R r;
+    r.set(x.get() + y.get());
+    return r;
+}
+
+template <class R1, class R2>
+quantity<R1, R2>
+operator-(const quantity<R1, R2>& x, const quantity<R1, R2>& y)
+{
+    typedef quantity<R1, R2> R;
+    R r;
+    r.set(x.get() - y.get());
+    return r;
+}
+
+// Example type-safe physics function
+Distance
+compute_distance(Speed v0, Time t, Acceleration a)
+{
+    return v0 * t + Scalar(.5) * a * t * t;  // if a units mistake is made here it won't compile
+}
+
+} // User1
+
+// Exercise example type-safe physics function and show interoperation
+// of custom time durations (User1::seconds) and standard time durations (std::hours).
+// Though input can be arbitrary (but type-safe) units, output is always in SI-units
+//   (a limitation of the simplified Units lib demoed here).
+
+
+
+int main()
+{
+    //~ typedef boost::ratio<8, BOOST_INTMAX_C(0x7FFFFFFFD)> R1;
+    //~ typedef boost::ratio<3, BOOST_INTMAX_C(0x7FFFFFFFD)> R2;
+    typedef User1::quantity<boost::ratio_subtract<boost::ratio<0>, boost::ratio<1> >::type,
+                             boost::ratio_subtract<boost::ratio<1>, boost::ratio<0> >::type > RR;
+    //~ typedef boost::ratio_subtract<R1, R2>::type RS;
+    //~ std::cout << RS::num << '/' << RS::den << '\n';
+
+
+    std::cout << "*************\n";
+    std::cout << "* testUser1 *\n";
+    std::cout << "*************\n";
+    User1::Distance d(( User1::mile(110) ));
+    boost_ex::chrono::hours h((2));
+    User1::Time t(( h ));
+    //~ boost_ex::chrono::seconds sss=boost_ex::chrono::duration_cast<boost_ex::chrono::seconds>(h);
+    //~ User1::seconds sss((120));
+    //~ User1::Time t(( sss ));
+
+    //typedef User1::quantity<boost::ratio_subtract<User1::Distance::time_dim, User1::Time::time_dim >::type,
+    //                        boost::ratio_subtract<User1::Distance::distance_dim, User1::Time::distance_dim >::type > R;
+    RR r=d / t;
+    //r.set(d.get() / t.get());
+
+    User1::Speed rc= r;
+    (void)rc;
+    User1::Speed s = d / t;
+    std::cout << "Speed = " << s.get() << " meters/sec\n";
+    User1::Acceleration a = User1::Distance( User1::foot(32.2) ) / User1::Time() / User1::Time();
+    std::cout << "Acceleration = " << a.get() << " meters/sec^2\n";
+    User1::Distance df = compute_distance(s, User1::Time( User1::seconds(0.5) ), a);
+    std::cout << "Distance = " << df.get() << " meters\n";
+    std::cout << "There are " << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
+    User1::meter mt = 1;
+    User1::mile mi = mt;
+    std::cout << " which is approximately " << mi.count() << '\n';
+    std::cout << "There are " << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
+    mi = 1;
+    mt = mi;
+    std::cout << " which is approximately " << mt.count() << '\n';
+    User1::attosecond as(1);
+    User1::seconds sec = as;
+    std::cout << "1 attosecond is " << sec.count() << " seconds\n";
+    std::cout << "sec = as;  // compiles\n";
+    sec = User1::seconds(1);
+    as = sec;
+    std::cout << "1 second is " << as.count() << " attoseconds\n";
+    std::cout << "as = sec;  // compiles\n";
+    std::cout << "\n";
+  return 0;
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/static_assert.hpp

@@ -0,0 +1,30 @@
+//  static_assert.hpp  --------------------------------------------------------------//
+
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP
+#define BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP
+
+#include "config.hpp"
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#elif defined(BOOST_CHRONO_USES_STATIC_ASSERT)
+#include <boost/static_assert.hpp>
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#elif defined(BOOST_CHRONO_USES_MPL_ASSERT)
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
+    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+#else
+//~ #elif defined(BOOST_CHRONO_USES_ARRAY_ASSERT)
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_JOIN(boost_chrono_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#endif // BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/type_traits/add_rvalue_reference.hpp

@@ -0,0 +1,67 @@
+//  add_rvalue_reference.hpp  ---------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           C++03 implementation of                          //
+//             20.7.6.2 Reference modifications [meta.trans.ref]              //
+//                          Written by Vicente J. Botet Escriba               //
+//                                                                            //
+// If T names an object or function type then the member typedef type
+// shall name T&&; otherwise, type shall name T. [ Note: This rule reflects
+// the semantics of reference collapsing. For example, when a type T names
+// a type T1&, the type add_rvalue_reference<T>::type is not an rvalue
+// reference. -end note ]
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+namespace type_traits_detail {
+
+    template <typename T, bool b>
+    struct add_rvalue_reference_helper
+    { typedef T   type; };
+
+    template <typename T>
+    struct add_rvalue_reference_helper<T, true>
+    {
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        typedef T&&   type;
+#else
+        typedef T   type;
+#endif
+    };
+
+    template <typename T>
+    struct add_rvalue_reference_imp
+    { 
+       typedef typename boost_ex::type_traits_detail::add_rvalue_reference_helper
+                  <T, (!boost::is_void<T>::value && !boost::is_reference<T>::value) >::type type; 
+    };
+
+}
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_rvalue_reference,T,typename boost_ex::type_traits_detail::add_rvalue_reference_imp<T>::type)
+
+}  // namespace boost_ex
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif  // BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/type_traits/common_type.hpp

@@ -0,0 +1,151 @@
+//  common_type.hpp  ---------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_COMMON_TYPE_HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_COMMON_TYPE_HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#define BOOST_EX_COMMON_TYPE_ARITY 3
+#endif
+
+//----------------------------------------------------------------------------//
+#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+#define BOOST_TYPEOF_SILENT
+#include <boost/typeof/typeof.hpp>   // boost wonders never cease!
+#endif
+
+//----------------------------------------------------------------------------//
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#elif defined(BOOST_EX_COMMON_TYPE_USES_STATIC_ASSERT)
+#include <boost/static_assert.hpp>
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#elif defined(BOOST_EX_COMMON_TYPE_USES_MPL_ASSERT)
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES)                                 \
+    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+#else
+//~ #elif defined(BOOST_EX_COMMON_TYPE_USES_ARRAY_ASSERT)
+#define BOOST_EX_COMMON_TYPE_CONCAT(A,B) A##B
+#define BOOST_EX_COMMON_TYPE_NAME(A,B) BOOST_EX_COMMON_TYPE_CONCAT(A,B)
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_EX_COMMON_TYPE_NAME(__boost_common_type_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_EX_COMMON_TYPE_USES_MPL_ASSERT)
+#define BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE "must be complete type"
+#endif
+
+#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+#include "detail/common_type.hpp"
+#include <boost/type_traits/remove_cv.hpp>
+#endif
+#include <boost/mpl/if.hpp>
+#include "declval.hpp"
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           C++03 implementation of                          //
+//             20.6.7 Other transformations [meta.trans.other]                //
+//                          Written by Howard Hinnant                         //
+//      Adapted for Boost by Beman Dawes, Vicente Botet and  Jeffrey Hellrung //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+// prototype
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<typename... T>
+    struct common_type;
+#else // or no specialization
+    template <class T, class U = void, class V = void>
+    struct common_type
+    {
+    public:
+        typedef typename common_type<typename common_type<T, U>::type, V>::type type;
+    };
+#endif
+
+
+// 1 arg
+    template<typename T>
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    struct common_type<T>
+#else
+    struct common_type<T, void, void>
+
+#endif
+    {
+        BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
+    public:
+        typedef T type;
+    };
+
+// 2 args
+namespace type_traits_detail {
+
+    template <class T, class U>
+    struct common_type_2
+    {
+    private:
+        BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
+        BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(U) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (U));
+        static bool declval_bool();  // workaround gcc bug; not required by std
+        static typename add_rvalue_reference<T>::type declval_T();  // workaround gcc bug; not required by std
+        static typename add_rvalue_reference<U>::type declval_U();  // workaround gcc bug; not required by std
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE)
+    public:
+        typedef decltype(declval<bool>() ? declval<T>() : declval<U>()) type;
+#elif defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+    public:
+    typedef typename detail_type_traits_common_type::common_type_impl<
+          typename remove_cv<T>::type,
+          typename remove_cv<U>::type
+      >::type type;
+#else
+    public:
+        //~ typedef BOOST_TYPEOF_TPL(declval_bool() ? declval_T() : declval_U()) type;
+        typedef BOOST_TYPEOF_TPL(declval<bool>() ? declval<T>() : declval<U>()) type;
+#endif
+    };
+
+    template <class T>
+    struct common_type_2<T, T>
+    {
+        typedef T type;
+    };
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class T, class U>
+    struct common_type<T, U>
+#else
+    template <class T, class U>
+    struct common_type<T, U, void>
+#endif
+    : type_traits_detail::common_type_2<T,U>
+    { };
+
+
+// 3 or more args
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<typename T, typename U, typename... V>
+    struct common_type<T, U, V...> {
+    public:
+        typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
+    };
+#endif
+}  // namespace boost_ex
+
+#endif  // BOOST_TYPE_TRAITS_EXT_COMMON_TYPE_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/type_traits/declval.hpp

@@ -0,0 +1,44 @@
+//  common_type.hpp  ---------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include "add_rvalue_reference.hpp"
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           C++03 implementation of                          //
+//                          Written by Vicente J. Botet Escriba               //
+//~ 20.3.4 Function template declval [declval]
+//~ 1 The library provides the function template declval to simplify the definition of expressions which occur as
+//~ unevaluated operands.
+//~ 2 Remarks: If this function is used, the program is ill-formed.
+//~ 3 Remarks: The template parameter T of declval may be an incomplete type.
+//~ [ Example:
+
+//~ template <class To, class From>
+//~ decltype(static_cast<To>(declval<From>())) convert(From&&);
+
+//~ declares a function template convert which only participats in overloading if the type From can be
+//~ explicitly converted to type To. For another example see class template common_type (20.7.6.6). -end
+//~ example ]
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+    template <typename T>
+    typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
+
+}  // namespace boost
+
+#endif  // BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/example/type_traits/detail/common_type.hpp

@@ -0,0 +1,316 @@
+/*******************************************************************************
+ * boost/type_traits/detail/common_type.hpp
+ *
+ * Copyright 2010, Jeffrey Hellrung.
+ * Distributed under the Boost Software License, Version 1.0.  (See accompanying
+ * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * struct boost::common_type<T,U>
+ *
+ * common_type<T,U>::type is the type of the expression
+ *     b() ? x() : y()
+ * where b() returns a bool, x() has return type T, and y() has return type U.
+ * See
+ *     http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm#common_type
+ *
+ * Note that this evaluates to void if one or both of T and U is void.
+ ******************************************************************************/
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/inserter.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/vector/vector0.hpp>
+#include <boost/mpl/vector/vector10.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/declval.hpp>
+
+namespace boost_ex
+{
+
+namespace detail_type_traits_common_type
+{
+
+/*******************************************************************************
+ * struct propagate_cv< From, To >
+ *
+ * This metafunction propagates cv-qualifiers on type From to type To.
+ ******************************************************************************/
+
+template< class From, class To >
+struct propagate_cv
+{ typedef To type; };
+template< class From, class To >
+struct propagate_cv< const From, To >
+{ typedef To const type; };
+template< class From, class To >
+struct propagate_cv< volatile From, To >
+{ typedef To volatile type; };
+template< class From, class To >
+struct propagate_cv< const volatile From, To >
+{ typedef To const volatile type; };
+
+/*******************************************************************************
+ * struct is_signable_integral<T>
+ *
+ * This metafunction determines if T is an integral type which can be made
+ * signed or unsigned.
+ ******************************************************************************/
+
+template< class T >
+struct is_signable_integral
+    : mpl::or_< is_integral<T>, is_enum<T> >
+{ };
+template<>
+struct is_signable_integral< bool >
+    : false_type
+{ };
+
+/*******************************************************************************
+ * struct sizeof_t<N>
+ * typedef ... yes_type
+ * typedef ... no_type
+ *
+ * These types are integral players in the use of the "sizeof trick", i.e., we
+ * can distinguish overload selection by inspecting the size of the return type
+ * of the overload.
+ ******************************************************************************/
+
+template< std::size_t N > struct sizeof_t { char _dummy[N]; };
+typedef sizeof_t<1> yes_type;
+typedef sizeof_t<2> no_type;
+BOOST_MPL_ASSERT_RELATION( sizeof( yes_type ), ==, 1 );
+BOOST_MPL_ASSERT_RELATION( sizeof( no_type ), ==, 2 );
+
+/*******************************************************************************
+ * rvalue_test(T&) -> no_type
+ * rvalue_test(...) -> yes_type
+ *
+ * These overloads are used to determine the rvalue-ness of an expression.
+ ******************************************************************************/
+
+template< class T > no_type rvalue_test(T&);
+yes_type rvalue_test(...);
+
+/*******************************************************************************
+ * struct conversion_test_overloads< Sequence >
+ *
+ * This struct has multiple overloads of the static member function apply, each
+ * one taking a single parameter of a type within the Boost.MPL sequence
+ * Sequence.  Each such apply overload has a return type with sizeof equal to
+ * one plus the index of the parameter type within Sequence.  Thus, we can
+ * deduce the type T of an expression as long as we can generate a finite set of
+ * candidate types containing T via these apply overloads and the "sizeof
+ * trick".
+ ******************************************************************************/
+
+template< class First, class Last, std::size_t Index >
+struct conversion_test_overloads_iterate
+    : conversion_test_overloads_iterate<
+          typename mpl::next< First >::type, Last, Index + 1
+      >
+{
+    using conversion_test_overloads_iterate<
+        typename mpl::next< First >::type, Last, Index + 1
+    >::apply;
+    static sizeof_t< Index + 1 >
+    apply(typename mpl::deref< First >::type);
+};
+
+template< class Last, std::size_t Index >
+struct conversion_test_overloads_iterate< Last, Last, Index >
+{ static sizeof_t< Index + 1 > apply(...); };
+
+template< class Sequence >
+struct conversion_test_overloads
+    : conversion_test_overloads_iterate<
+          typename mpl::begin< Sequence >::type,
+          typename mpl::end< Sequence >::type,
+          0
+      >
+{ };
+
+/*******************************************************************************
+ * struct select< Sequence, Index >
+ *
+ * select is synonymous with mpl::at_c unless Index equals the size of the
+ * Boost.MPL Sequence, in which case this evaluates to void.
+ ******************************************************************************/
+
+template<
+    class Sequence, int Index,
+    int N = mpl::size< Sequence >::value
+>
+struct select
+    : mpl::at_c< Sequence, Index >
+{ };
+template< class Sequence, int N >
+struct select< Sequence, N, N >
+{ typedef void type; };
+
+/*******************************************************************************
+ * class deduce_common_type< T, U, NominalCandidates >
+ * struct nominal_candidates<T,U>
+ * struct common_type_dispatch_on_rvalueness<T,U>
+ * struct common_type_impl<T,U>
+ *
+ * These classes and structs implement the logic behind common_type, which goes
+ * roughly as follows.  Let C be the type of the conditional expression
+ *     declval< bool >() ? declval<T>() : declval<U>()
+ * if C is an rvalue, then:
+ *     let T' and U' be T and U stripped of reference- and cv-qualifiers
+ *     if T' and U' are pointer types, say, T' = V* and U' = W*, then:
+ *         define the set of NominalCandidates to be
+ *             { V*, W*, V'*, W'* }
+ *           where V' is V with whatever cv-qualifiers are on W, and W' is W
+ *           with whatever cv-qualifiers are on V
+ *     else T' and U' are both "signable integral types" (integral and enum
+ *       types excepting bool), then:
+ *         define the set of NominalCandidates to be
+ *             { unsigned(T'), unsigned(U'), signed(T'), signed(U') }
+ *           where unsigned(X) is make_unsigned<X>::type and signed(X) is
+ *           make_signed<X>::type
+ *     else
+ *         define the set of NominalCandidates to be
+ *             { T', U' }
+ * else
+ *     let V and W be T and U stripped of reference-qualifiers
+ *     define the set of NominalCandidates to be
+ *         { V&, W&, V'&, W'& }
+ *     where V' is V with whatever cv-qualifiers are on W, and W' is W with
+ *       whatever cv-qualifiers are on V
+ * define the set of Candidates to be equal to the set of NominalCandidates with
+ * duplicates removed, and use this set of Candidates to determine C using the
+ * conversion_test_overloads struct
+ ******************************************************************************/
+
+template< class T, class U, class NominalCandidates >
+class deduce_common_type
+{
+    typedef typename mpl::copy<
+        NominalCandidates,
+        mpl::inserter<
+            mpl::vector0<>,
+            mpl::if_<
+                mpl::contains< mpl::_1, mpl::_2 >,
+                mpl::_1,
+                mpl::push_back< mpl::_1, mpl::_2 >
+            >
+        >
+    >::type candidate_types;
+    static const int best_candidate_index =
+        sizeof( conversion_test_overloads< candidate_types >::apply(
+            declval< bool >() ? declval<T>() : declval<U>()
+        ) ) - 1;
+public:
+    typedef typename select< candidate_types, best_candidate_index >::type type;
+};
+
+template<
+    class T, class U,
+    class V = typename remove_cv< typename remove_reference<T>::type >::type,
+    class W = typename remove_cv< typename remove_reference<U>::type >::type,
+    bool = is_signable_integral<V>::value && is_signable_integral<W>::value
+>
+struct nominal_candidates;
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V, W, false >
+{ typedef mpl::vector2<V,W> type; };
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V, W, true >
+{
+    typedef mpl::vector4<
+        typename make_unsigned<V>::type,
+        typename make_unsigned<W>::type,
+        typename make_signed<V>::type,
+        typename make_signed<W>::type
+    > type;
+};
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V*, W*, false >
+{
+    typedef mpl::vector4<
+        V*, W*,
+        typename propagate_cv<W,V>::type *,
+        typename propagate_cv<V,W>::type *
+    > type;
+};
+
+template<
+    class T, class U,
+    bool = sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
+        declval< bool >() ? declval<T>() : declval<U>()
+    ) ) == sizeof( yes_type )
+>
+struct common_type_dispatch_on_rvalueness;
+
+template< class T, class U >
+struct common_type_dispatch_on_rvalueness< T, U, true >
+    : deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
+{ };
+
+template< class T, class U >
+struct common_type_dispatch_on_rvalueness< T, U, false >
+{
+private:
+    typedef typename remove_reference<T>::type unrefed_T_type;
+    typedef typename remove_reference<U>::type unrefed_U_type;
+public:
+    typedef typename deduce_common_type<
+        T, U,
+        mpl::vector4<
+            unrefed_T_type &,
+            unrefed_U_type &,
+            typename propagate_cv< unrefed_U_type, unrefed_T_type >::type &,
+            typename propagate_cv< unrefed_T_type, unrefed_U_type >::type &
+        >
+    >::type type;
+};
+
+template< class T, class U >
+struct common_type_impl
+    : common_type_dispatch_on_rvalueness<T,U>
+{ };
+
+template< class T > struct common_type_impl< T, void > { typedef void type; };
+template< class T > struct common_type_impl< void, T > { typedef void type; };
+template<> struct common_type_impl< void, void > { typedef void type; };
+template< > struct common_type_impl< char, short> { typedef int type; };
+template< > struct common_type_impl< short, char> { typedef int type; };
+template< > struct common_type_impl< unsigned char, short> { typedef int type; };
+template< > struct common_type_impl< short, unsigned char> { typedef int type; };
+template< > struct common_type_impl< unsigned char, unsigned short> { typedef int type; };
+template< > struct common_type_impl< unsigned short, unsigned char> { typedef int type; };
+template< > struct common_type_impl< char, unsigned short> { typedef int type; };
+template< > struct common_type_impl< unsigned short, char> { typedef int type; };
+
+} // namespace detail_type_traits_common_type
+
+
+} // namespace boost_ex
+
+#endif // BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio.hpp

@@ -0,0 +1,14 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_HPP
+#define BOOST_RATIO_HPP
+
+#include <boost/ratio/include.hpp>
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/config.hpp

@@ -0,0 +1,96 @@
+//  config.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2012 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_CONFIG_HPP
+#define BOOST_RATIO_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+
+
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  if ! defined BOOST_NO_CXX11_U16STRING
+#    define BOOST_NO_CXX11_U16STRING
+#  endif
+#  if ! defined BOOST_NO_CXX11_U32STRING
+#    define BOOST_NO_CXX11_U32STRING
+#  endif
+#endif
+
+
+#if !defined BOOST_RATIO_VERSION
+#define BOOST_RATIO_VERSION 1
+#else
+#if BOOST_RATIO_VERSION!=1  && BOOST_RATIO_VERSION!=2
+#error "BOOST_RATIO_VERSION must be 1 or 2"
+#endif
+#endif
+
+#if BOOST_RATIO_VERSION==1
+#if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
+#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
+#endif
+#endif
+
+#if BOOST_RATIO_VERSION==2
+#if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
+#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
+#endif
+#endif
+
+#ifdef INTMAX_C
+#define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
+#elif __cplusplus >= 201103L
+#define BOOST_RATIO_INTMAX_C(a) a##LL
+#else
+#define BOOST_RATIO_INTMAX_C(a) a##L
+#endif
+
+#ifdef UINTMAX_C
+#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
+#elif __cplusplus >= 201103L
+#define BOOST_RATIO_UINTMAX_C(a) a##ULL
+#else
+#define BOOST_RATIO_UINTMAX_C(a) a##UL
+#endif
+
+#define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
+
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
+#include <boost/static_assert.hpp>
+#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#elif defined(BOOST_RATIO_USES_MPL_ASSERT)
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
+    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+#else
+//~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
+#define BOOST_RATIO_CONCAT(A,B) A##B
+#define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
+#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
+#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
+#define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
+#define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
+#define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
+#define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
+#define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
+#define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
+#endif
+
+
+//#define BOOST_RATIO_EXTENSIONS
+
+#endif  // header

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/detail/mpl/abs.hpp

@@ -0,0 +1,89 @@
+////////////////////////////////////////////////////////////////////
+//
+// Copyright Vicente J. Botet Escriba 2010
+//
+// Distributed under the 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/mpl for documentation.
+//
+////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MPL_ABS_HPP_INCLUDED
+#define BOOST_MPL_ABS_HPP_INCLUDED
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
+    && ( defined(BOOST_MSVC) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+        )
+
+#   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
+
+#endif
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct abs_impl;
+
+template< typename T > struct abs_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(N)
+    >
+struct abs
+    : abs_impl<
+          typename abs_tag<N>::type
+        >::template apply<N>::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1, abs, (N))
+};
+
+BOOST_MPL_AUX_NA_SPEC(1, abs)
+
+template<
+      typename T
+    , T n1
+    >
+struct abs_c
+    : abs<integral_c<T,n1> >
+{
+};
+
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
+namespace aux {
+template< typename T, T n > struct abs_wknd
+{
+    BOOST_STATIC_CONSTANT(T, value = (n < 0 ? -n : n));
+    typedef integral_c<T,value> type;
+};
+}
+#endif
+
+template<>
+struct abs_impl<integral_c_tag>
+{
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
+    template< typename N > struct apply
+        : aux::abs_wknd< typename N::value_type, N::value >
+#else
+    template< typename N > struct apply
+        : integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >
+#endif
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_ABS_HPP_INCLUDED

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/detail/mpl/gcd.hpp

@@ -0,0 +1,124 @@
+////////////////////////////////////////////////////////////////////
+//
+// Copyright Vicente J. Botet Escriba 2010
+//
+// Distributed under the 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/mpl for documentation.
+//
+////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MPL_GCD_HPP_INCLUDED
+#define BOOST_MPL_GCD_HPP_INCLUDED
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+#include <boost/mpl/aux_/largest_int.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/dependent_nttp.hpp>
+#include <boost/cstdint.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
+    && ( defined(BOOST_MSVC) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+        )
+
+#   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
+
+#endif
+
+namespace boost { namespace mpl {
+
+template< typename Tag1, typename Tag2 > struct gcd_impl;
+
+template< typename T > struct gcd_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(N1)
+    , typename BOOST_MPL_AUX_NA_PARAM(N2)
+    >
+struct gcd
+    : gcd_impl<
+          typename gcd_tag<N1>::type
+        , typename gcd_tag<N2>::type
+        >::template apply<N1, N2>::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, gcd, (N1, N2))
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, gcd)
+
+template<
+      typename T
+    , T n1
+    , T n2
+    >
+struct gcd_c
+    : gcd<integral_c<T,n1>,integral_c<T,n2> >
+{
+};
+
+namespace aux {
+
+  // Workaround for error: the type of partial specialization template parameter constant "n2"
+    // depends on another template parameter
+    // Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
+#if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+  template< typename T1, boost::intmax_t n1, bool n1_is_0
+                  , typename T2, boost::intmax_t n2, bool n2_is_0 >
+      struct gcd_aux
+          : gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
+      struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
+      struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
+      {};
+
+#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+    template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
+    struct gcd_aux
+
+        : gcd_aux<T2, n2, n2==0,
+                    typename aux::largest_int<T1, T2>::type,
+                    //~ T1,
+                    (n1 % n2), (n1 % n2)==0>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2>
+    struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2, bool C>
+    struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
+    {};
+#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+}
+
+template<>
+struct gcd_impl<integral_c_tag, integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+        : abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
+                        typename N2::value_type, N2::value, N2::value==0  > >
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_GCD_HPP_INCLUDED

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/detail/mpl/lcm.hpp

@@ -0,0 +1,126 @@
+////////////////////////////////////////////////////////////////////
+//
+// Copyright Vicente J. Botet Escriba 2010
+//
+// Distributed under the 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/mpl for documentation.
+//
+////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MPL_LCM_HPP_INCLUDED
+#define BOOST_MPL_LCM_HPP_INCLUDED
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+#include <boost/mpl/aux_/largest_int.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/dependent_nttp.hpp>
+#include <boost/cstdint.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
+    && ( defined(BOOST_MSVC) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+        )
+
+#   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
+
+#endif
+
+namespace boost { namespace mpl {
+
+template< typename Tag1, typename Tag2 > struct lcm_impl;
+
+template< typename T > struct lcm_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(N1)
+    , typename BOOST_MPL_AUX_NA_PARAM(N2)
+    >
+struct lcm
+    : lcm_impl<
+          typename lcm_tag<N1>::type
+        , typename lcm_tag<N2>::type
+        >::template apply<N1, N2>::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, lcm, (N1, N2))
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, lcm)
+
+template<
+      typename T
+    , T n1
+    , T n2
+    >
+struct lcm_c
+    : lcm<integral_c<T,n1>,integral_c<T,n2> >
+{
+};
+
+
+namespace aux {
+  // Workaround for error: the type of partial specialization template parameter constant "n2"
+  // depends on another template parameter
+  // Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
+  #if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+  template< typename T1, boost::intmax_t n1, bool n1_is_0
+                          , typename T2, boost::intmax_t n2, bool n2_is_0 >
+      struct lcm_aux
+          : abs<integral_c< typename aux::largest_int<T1, T2>::type,
+              ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
+          > >
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
+      struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
+      struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
+      {};
+
+
+#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+
+    template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
+    struct lcm_aux
+
+        : abs<integral_c< typename aux::largest_int<T1, T2>::type,
+            ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
+        > >
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2>
+    struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2, bool C>
+    struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
+    {};
+#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+}
+
+template<>
+struct lcm_impl<integral_c_tag, integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+        : abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
+                        typename N2::value_type, N2::value, N2::value==0  > >
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_LCM_HPP_INCLUDED

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/detail/mpl/sign.hpp

@@ -0,0 +1,89 @@
+////////////////////////////////////////////////////////////////////
+//
+// Copyright Vicente J. Botet Escriba 2010
+//
+// Distributed under the 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/mpl for documentation.
+//
+////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MPL_SIGN_HPP_INCLUDED
+#define BOOST_MPL_SIGN_HPP_INCLUDED
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
+    && ( defined(BOOST_MSVC) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+        )
+
+#   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
+
+#endif
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct sign_impl;
+
+template< typename T > struct sign_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(N)
+    >
+struct sign
+    : sign_impl<
+          typename sign_tag<N>::type
+        >::template apply<N>::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1, sign, (N))
+};
+
+BOOST_MPL_AUX_NA_SPEC(1, sign)
+
+template<
+      typename T
+    , T n1
+    >
+struct sign_c
+    : sign<integral_c<T,n1> >
+{
+};
+
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
+namespace aux {
+template< typename T, T n > struct sign_wknd
+{
+    BOOST_STATIC_CONSTANT(T, value = (n == 0 ? 0 : (n < 0 ? -1 : 1)));
+    typedef integral_c<T,value> type;
+};
+}
+#endif
+
+template<>
+struct sign_impl<integral_c_tag>
+{
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
+    template< typename N > struct apply
+        : aux::sign_wknd< typename N::value_type, N::value >
+#else
+    template< typename N > struct apply
+        : integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >
+#endif
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_SIGN_HPP_INCLUDED

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/detail/overflow_helpers.hpp

@@ -0,0 +1,367 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+
+This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
+Many thanks to Howard for making his code available under the Boost license.
+The original code was modified to conform to Boost conventions and to section
+20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
+paper N2798.
+See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
+
+time2_demo contained this comment:
+
+    Much thanks to Andrei Alexandrescu,
+                   Walter Brown,
+                   Peter Dimov,
+                   Jeff Garland,
+                   Terry Golubiewski,
+                   Daniel Krugler,
+                   Anthony Williams.
+*/
+
+// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
+
+#ifndef BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
+#define BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
+
+#include <boost/ratio/config.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+#include <boost/ratio/detail/mpl/sign.hpp>
+#include <cstdlib>
+#include <climits>
+#include <limits>
+#include <boost/cstdint.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/integer_traits.hpp>
+
+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif
+
+namespace boost
+{
+
+//----------------------------------------------------------------------------//
+//                                 helpers                                    //
+//----------------------------------------------------------------------------//
+
+namespace ratio_detail
+{
+
+  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
+  class br_add;
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_add<X, Y, 1>
+  {
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      BOOST_RATIO_STATIC_ASSERT(X <= max - Y , BOOST_RATIO_OVERFLOW_IN_ADD, ());
+  public:
+      static const boost::intmax_t value = X + Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_add<X, Y, 0>
+  {
+  public:
+      static const boost::intmax_t value = X;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_add<X, Y, -1>
+  {
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      BOOST_RATIO_STATIC_ASSERT(min - Y <= X, BOOST_RATIO_OVERFLOW_IN_ADD, ());
+  public:
+      static const boost::intmax_t value = X + Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
+  class br_sub;
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_sub<X, Y, 1>
+  {
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      BOOST_RATIO_STATIC_ASSERT(min + Y <= X, BOOST_RATIO_OVERFLOW_IN_SUB, ());
+  public:
+      static const boost::intmax_t value = X - Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_sub<X, Y, 0>
+  {
+  public:
+      static const boost::intmax_t value = X;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_sub<X, Y, -1>
+  {
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      BOOST_RATIO_STATIC_ASSERT(X <= max + Y, BOOST_RATIO_OVERFLOW_IN_SUB, ());
+  public:
+      static const boost::intmax_t value = X - Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_mul
+  {
+      static const boost::intmax_t nan =
+          boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
+      static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;
+
+      BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
+      BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
+      BOOST_RATIO_STATIC_ASSERT(a_x <= max / a_y, BOOST_RATIO_OVERFLOW_IN_MUL, ());
+  public:
+      static const boost::intmax_t value = X * Y;
+  };
+
+  template <boost::intmax_t Y>
+  class br_mul<0, Y>
+  {
+  public:
+      static const boost::intmax_t value = 0;
+  };
+
+  template <boost::intmax_t X>
+  class br_mul<X, 0>
+  {
+  public:
+      static const boost::intmax_t value = 0;
+  };
+
+  template <>
+  class br_mul<0, 0>
+  {
+  public:
+      static const boost::intmax_t value = 0;
+  };
+
+  // Not actually used but left here in case needed in future maintenance
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_div
+  {
+      static const boost::intmax_t nan = boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
+      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
+
+      BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
+      BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
+      BOOST_RATIO_STATIC_ASSERT(Y != 0, BOOST_RATIO_DIVIDE_BY_0, ());
+  public:
+      static const boost::intmax_t value = X / Y;
+  };
+
+  // ratio arithmetic
+  template <class R1, class R2> struct ratio_add;
+  template <class R1, class R2> struct ratio_subtract;
+  template <class R1, class R2> struct ratio_multiply;
+  template <class R1, class R2> struct ratio_divide;
+
+  template <class R1, class R2>
+  struct ratio_add
+  {
+      //The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num *
+      //R2::den + R2::num * R1::den and T2 has the value R1::den * R2::den.
+      // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
+  private:
+      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
+      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
+  public:
+      // No need to normalize as ratio_multiply is already normalized
+      typedef typename ratio_multiply
+         <
+             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
+             ratio
+             <
+                 boost::ratio_detail::br_add
+                 <
+                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+                 >::value,
+                 R2::den
+             >
+         >::type type;
+  };
+  template <class R, boost::intmax_t D>
+  struct ratio_add<R, ratio<0,D> >
+  {
+    typedef R type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_subtract
+  {
+      //The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value
+      // R1::num *R2::den - R2::num * R1::den and T2 has the value R1::den * R2::den.
+      // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
+  private:
+      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
+      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
+  public:
+      // No need to normalize as ratio_multiply is already normalized
+      typedef typename ratio_multiply
+         <
+             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
+             ratio
+             <
+                 boost::ratio_detail::br_sub
+                 <
+                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+                 >::value,
+                 R2::den
+             >
+         >::type type;
+  };
+
+  template <class R, boost::intmax_t D>
+  struct ratio_subtract<R, ratio<0,D> >
+  {
+    typedef R type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_multiply
+  {
+      // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type.
+      // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
+  private:
+     static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
+     static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
+  public:
+      typedef typename ratio
+         <
+             boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
+             boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
+         >::type type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_divide
+  {
+      // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den, R2::num * R1::den>::type.
+      // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
+  private:
+      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
+      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
+  public:
+      typedef typename ratio
+         <
+             boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+             boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+         >::type type;
+  };
+  template <class R1, class R2>
+  struct is_evenly_divisible_by
+  {
+  private:
+      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
+      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
+  public:
+      typedef integral_constant<bool,
+             ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
+      > type;
+  };
+
+  template <class T>
+  struct is_ratio : public boost::false_type
+  {};
+  template <boost::intmax_t N, boost::intmax_t D>
+  struct is_ratio<ratio<N, D> > : public boost::true_type
+  {};
+
+  template <class R1, class R2,
+            boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
+            boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
+  struct ratio_less1
+  {
+    static const bool value = Q1 < Q2;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q>
+  struct ratio_less1<R1, R2, Q, 0, Q, 0>
+  {
+    static const bool value = false;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
+  struct ratio_less1<R1, R2, Q, 0, Q, M2>
+  {
+    static const bool value = true;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
+  struct ratio_less1<R1, R2, Q, M1, Q, 0>
+  {
+    static const bool value = false;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
+  struct ratio_less1<R1, R2, Q, M1, Q, M2>
+  {
+    static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
+                                            >::value;
+  };
+
+  template <
+      class R1,
+      class R2,
+      boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
+    boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
+>
+  struct ratio_less
+  {
+      static const bool value = S1 < S2;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less<R1, R2, 1LL, 1LL>
+  {
+      static const bool value = ratio_less1<R1, R2>::value;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less<R1, R2, -1LL, -1LL>
+  {
+      static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
+                                            ratio<-R1::num, R1::den> >::value;
+  };
+
+
+}  // namespace ratio_detail
+
+}  // namespace boost
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/include.hpp

@@ -0,0 +1,16 @@
+//  include.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_RATIO_INCLUDE_HPP
+#define BOOST_RATIO_INCLUDE_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/ratio_io.hpp>
+#ifdef BOOST_RATIO_EXTENSIONS
+#include <boost/ratio/mpl/rational_constant.hpp>
+#endif
+#endif  // BOOST_RATIO_INCLUDE_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/abs.hpp

@@ -0,0 +1,30 @@
+//  abs.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_ABS_HPP
+#define BOOST_RATIO_MPL_ABS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct abs_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_abs<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_ABS_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/arithmetic.hpp

@@ -0,0 +1,22 @@
+//  arithmetic.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_ARITHMETIC_HPP
+#define BOOST_RATIO_MPL_ARITHMETIC_HPP
+
+#include <boost/ratio/mpl/plus.hpp>
+#include <boost/ratio/mpl/minus.hpp>
+#include <boost/ratio/mpl/times.hpp>
+#include <boost/ratio/mpl/divides.hpp>
+#include <boost/ratio/mpl/negate.hpp>
+#include <boost/ratio/mpl/abs.hpp>
+#include <boost/ratio/mpl/sign.hpp>
+#include <boost/ratio/mpl/gcd.hpp>
+#include <boost/ratio/mpl/lcm.hpp>
+
+#endif  // BOOST_RATIO_MPL_ARITHMETIC_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/comparison.hpp

@@ -0,0 +1,19 @@
+//  comparison.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_COMPARISON_HPP
+#define BOOST_RATIO_MPL_COMPARISON_HPP
+
+#include <boost/ratio/mpl/equal_to.hpp>
+#include <boost/ratio/mpl/not_equal_to.hpp>
+#include <boost/ratio/mpl/less.hpp>
+#include <boost/ratio/mpl/less_equal.hpp>
+#include <boost/ratio/mpl/greater.hpp>
+#include <boost/ratio/mpl/greater_equal.hpp>
+
+#endif  // BOOST_RATIO_MPL_COMPARISON_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/divides.hpp

@@ -0,0 +1,30 @@
+//  divides.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_DIVIDES_HPP
+#define BOOST_RATIO_MPL_DIVIDES_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/divides.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct divides_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_divide<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_DIVIDES_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/equal_to.hpp

@@ -0,0 +1,30 @@
+//  equal_to.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_EQUAL_TO_HPP
+#define BOOST_RATIO_MPL_EQUAL_TO_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/equal_to.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct equal_to_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_EQUAL_TO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/gcd.hpp

@@ -0,0 +1,30 @@
+//  gcd.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_GCD_HPP
+#define BOOST_RATIO_MPL_GCD_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/gcd.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct gcd_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_gcd<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GCD_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/greater.hpp

@@ -0,0 +1,30 @@
+//  greater.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_GREATER_HPP
+#define BOOST_RATIO_MPL_GREATER_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/greater.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct greater_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_greater<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GREATER_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/greater_equal.hpp

@@ -0,0 +1,30 @@
+//  greater_equal.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_GREATER_EQUAL_HPP
+#define BOOST_RATIO_MPL_GREATER_EQUAL_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/greater_equal.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct greater_equal_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_greater_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GREATER_EQUAL_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/lcm.hpp

@@ -0,0 +1,30 @@
+//  lcm.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_LCM_HPP
+#define BOOST_RATIO_MPL_LCM_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/lcm.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct lcm_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_lcm<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LCM_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/less.hpp

@@ -0,0 +1,30 @@
+//  less.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_LESS_HPP
+#define BOOST_RATIO_MPL_LESS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/less.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct less_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_less<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LESS_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/less_equal.hpp

@@ -0,0 +1,30 @@
+//  less_equal.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_LESS_EQUAL_HPP
+#define BOOST_RATIO_MPL_LESS_EQUAL_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/less_equal.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct less_equal_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_less_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LESS_EQUAL_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/minus.hpp

@@ -0,0 +1,30 @@
+//  minus.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_MINUS_HPP
+#define BOOST_RATIO_MPL_MINUS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/minus.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct minus_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_subtract<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_MINUS_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/negate.hpp

@@ -0,0 +1,30 @@
+//  negate.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_NEGATE_HPP
+#define BOOST_RATIO_MPL_NEGATE_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/negate.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct negate_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_negate<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NEGATE_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/not_equal_to.hpp

@@ -0,0 +1,30 @@
+//  not_equal_to.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_NOT_EQUAL_TO_HPP
+#define BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/not_equal_to.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct not_equal_to_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_not_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/numeric_cast.hpp

@@ -0,0 +1,31 @@
+//  numeric_cast.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_NUMERIC_CAST_HPP
+#define BOOST_RATIO_MPL_NUMERIC_CAST_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/ratio/mpl/rational_c_tag.hpp>
+#include <boost/mpl/numeric_cast.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<> struct numeric_cast< integral_c_tag,rational_c_tag >
+{
+    template< typename N > struct apply
+        : ratio< N::value, 1 >
+    {
+    };
+};
+    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NUMERIC_CAST_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/plus.hpp

@@ -0,0 +1,30 @@
+//  plus.hpp
+//
+//  (C) Copyright 2011Vicente J. Botet Escriba
+//  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_RATIO_MPL_PLUS_HPP
+#define BOOST_RATIO_MPL_PLUS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/plus.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct plus_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_add<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_PLUS_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/rational_c_tag.hpp

@@ -0,0 +1,25 @@
+//  abs.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_RATIONAL_C_TAG_HPP
+#define BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP
+
+#ifdef BOOST_RATIO_EXTENSIONS
+
+#include <boost/mpl/int.hpp>
+
+namespace boost {
+namespace mpl {
+
+struct rational_c_tag : int_<10> {};
+
+}
+}
+
+#endif // BOOST_RATIO_EXTENSIONS
+#endif  // BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/rational_constant.hpp

@@ -0,0 +1,15 @@
+//  rational_constant.hpp  ---------------------------------------------------------------//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
+#define BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
+
+#include <boost/ratio/mpl/rational_c_tag.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/mpl/arithmetic.hpp>
+#include <boost/ratio/mpl/comparison.hpp>
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/sign.hpp

@@ -0,0 +1,30 @@
+//  sign.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_SIGN_HPP
+#define BOOST_RATIO_MPL_SIGN_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/sign.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct sign_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_sign<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_SIGN_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/mpl/times.hpp

@@ -0,0 +1,30 @@
+//  times.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  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_RATIO_MPL_TIMES_HPP
+#define BOOST_RATIO_MPL_TIMES_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/times.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct times_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_multiply<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_TIMES_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/ratio.hpp

@@ -0,0 +1,293 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+
+This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
+Many thanks to Howard for making his code available under the Boost license.
+The original code was modified to conform to Boost conventions and to section
+20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
+paper N2798.
+See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
+
+time2_demo contained this comment:
+
+    Much thanks to Andrei Alexandrescu,
+                   Walter Brown,
+                   Peter Dimov,
+                   Jeff Garland,
+                   Terry Golubiewski,
+                   Daniel Krugler,
+                   Anthony Williams.
+*/
+
+// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
+
+#ifndef BOOST_RATIO_RATIO_HPP
+#define BOOST_RATIO_RATIO_HPP
+
+#include <boost/ratio/config.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+#include <boost/ratio/detail/mpl/sign.hpp>
+#include <boost/ratio/detail/mpl/gcd.hpp>
+#include <boost/ratio/detail/mpl/lcm.hpp>
+#include <cstdlib>
+#include <climits>
+#include <limits>
+#include <boost/cstdint.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/ratio/ratio_fwd.hpp>
+#include <boost/ratio/detail/overflow_helpers.hpp>
+#ifdef BOOST_RATIO_EXTENSIONS
+#include <boost/rational.hpp>
+#include <boost/ratio/mpl/rational_c_tag.hpp>
+#endif
+
+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif
+
+namespace boost
+{
+
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                20.6.1 Class template ratio [ratio.ratio]                   //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <boost::intmax_t N, boost::intmax_t D>
+class ratio
+{
+    static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
+    static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
+    BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
+    static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
+      * mpl::sign_c<boost::intmax_t,D>::value;
+    static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
+public:
+    BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
+    BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
+
+#ifdef BOOST_RATIO_EXTENSIONS
+    typedef mpl::rational_c_tag tag;
+    typedef boost::rational<boost::intmax_t> value_type;
+    typedef boost::intmax_t num_type;
+    typedef boost::intmax_t den_type;
+    ratio()
+    {}
+    template <boost::intmax_t _N2, boost::intmax_t _D2>
+    ratio(const ratio<_N2, _D2>&,
+        typename enable_if_c
+            <
+                (ratio<_N2, _D2>::num == num &&
+                ratio<_N2, _D2>::den == den)
+            >::type* = 0)
+    {}
+
+    template <boost::intmax_t _N2, boost::intmax_t _D2>
+        typename enable_if_c
+        <
+            (ratio<_N2, _D2>::num == num &&
+            ratio<_N2, _D2>::den == den),
+            ratio&
+        >::type
+    operator=(const ratio<_N2, _D2>&) {return *this;}
+
+    static value_type value() {return value_type(num,den);}
+    value_type operator()() const {return value();}
+#endif
+    typedef ratio<num, den> type;
+};
+
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+template <boost::intmax_t N, boost::intmax_t D>
+const    boost::intmax_t ratio<N, D>::num;
+template <boost::intmax_t N, boost::intmax_t D>
+const    boost::intmax_t ratio<N, D>::den;
+#endif
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                20.6.2 Arithmetic on ratio types [ratio.arithmetic]         //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <class R1, class R2>
+struct ratio_add
+: boost::ratio_detail::ratio_add<R1, R2>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_subtract
+: boost::ratio_detail::ratio_subtract<R1, R2>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_multiply
+: boost::ratio_detail::ratio_multiply<R1, R2>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_divide
+: boost::ratio_detail::ratio_divide<R1, R2>::type
+{
+};
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                20.6.3 Comparision of ratio types [ratio.comparison]        //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+// ratio_equal
+
+template <class R1, class R2>
+struct ratio_equal
+    : public boost::integral_constant<bool,
+                               (R1::num == R2::num && R1::den == R2::den)>
+{};
+
+template <class R1, class R2>
+struct ratio_not_equal
+    : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
+{};
+
+// ratio_less
+
+template <class R1, class R2>
+struct ratio_less
+    : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
+{};
+
+template <class R1, class R2>
+struct ratio_less_equal
+    : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
+{};
+
+template <class R1, class R2>
+struct ratio_greater
+    : boost::integral_constant<bool, ratio_less<R2, R1>::value>
+{};
+
+template <class R1, class R2>
+struct ratio_greater_equal
+    : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
+{};
+
+template <class R1, class R2>
+struct ratio_gcd :
+    ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
+        mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
+{
+};
+
+    //----------------------------------------------------------------------------//
+    //                                                                            //
+    //                More arithmetic on ratio types [ratio.arithmetic]           //
+    //                                                                            //
+    //----------------------------------------------------------------------------//
+
+#ifdef BOOST_RATIO_EXTENSIONS
+template <class R>
+struct ratio_negate
+    : ratio<-R::num, R::den>::type
+{
+};
+template <class R>
+struct ratio_abs
+    : ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
+{
+};
+template <class R>
+struct ratio_sign
+    : mpl::sign_c<boost::intmax_t, R::num>
+{
+};
+
+template <class R>
+struct ratio_inverse
+    : ratio<R::den, R::num>::type
+{
+};
+
+
+template <class R1, class R2>
+struct ratio_lcm :
+    ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
+        mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_modulo :
+    ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
+{
+};
+
+namespace detail {
+  template <class R1, class R2, bool r1ltr2>
+  struct ratio_min : R1 {};
+  template <class R1, class R2>
+  struct ratio_min<R1,R2,false> : R2 {};
+
+  template <class R1, class R2, bool r1ltr2>
+  struct ratio_max : R2 {};
+  template <class R1, class R2>
+  struct ratio_max<R1,R2,false> : R1 {};
+}
+
+template <class R1, class R2>
+struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
+{
+};
+
+template<typename R, int p>
+struct ratio_power :
+  ratio_multiply<
+    typename ratio_power<R, p%2>::type,
+    typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
+  >::type
+{};
+
+template<typename R>
+struct ratio_power<R, 0> : ratio<1>::type {};
+
+template<typename R>
+struct ratio_power<R, 1> : R {};
+
+template<typename R>
+struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
+
+#endif
+}  // namespace boost
+
+
+#endif  // BOOST_RATIO_RATIO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/include/boost/ratio/ratio_fwd.hpp

@@ -0,0 +1,109 @@
+//  ratio_fwd.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+
+This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
+Many thanks to Howard for making his code available under the Boost license.
+The original code was modified to conform to Boost conventions and to section
+20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
+paper N2798.
+See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
+
+time2_demo contained this comment:
+
+    Much thanks to Andrei Alexandrescu,
+                   Walter Brown,
+                   Peter Dimov,
+                   Jeff Garland,
+                   Terry Golubiewski,
+                   Daniel Krugler,
+                   Anthony Williams.
+*/
+
+// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
+
+#ifndef BOOST_RATIO_RATIO_FWD_HPP
+#define BOOST_RATIO_RATIO_FWD_HPP
+
+#include <boost/ratio/config.hpp>
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif
+
+namespace boost
+{
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//              20.6 Compile-time rational arithmetic [ratio]                 //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+// ratio
+template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
+
+// ratio arithmetic
+template <class R1, class R2> struct ratio_add;
+template <class R1, class R2> struct ratio_subtract;
+template <class R1, class R2> struct ratio_multiply;
+template <class R1, class R2> struct ratio_divide;
+#ifdef BOOST_RATIO_EXTENSIONS
+template <class R1, class R2> struct ratio_gcd;
+template <class R1, class R2> struct ratio_lcm;
+template <class R> struct ratio_negate;
+template <class R> struct ratio_abs;
+template <class R> struct ratio_sign;
+template <class R, int P> struct ratio_power;
+#endif
+
+// ratio comparison
+template <class R1, class R2> struct ratio_equal;
+template <class R1, class R2> struct ratio_not_equal;
+template <class R1, class R2> struct ratio_less;
+template <class R1, class R2> struct ratio_less_equal;
+template <class R1, class R2> struct ratio_greater;
+template <class R1, class R2> struct ratio_greater_equal;
+
+// convenience SI typedefs
+typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000000000)> atto;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),    BOOST_RATIO_INTMAX_C(1000000000000000)> femto;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),       BOOST_RATIO_INTMAX_C(1000000000000)> pico;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),          BOOST_RATIO_INTMAX_C(1000000000)> nano;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),             BOOST_RATIO_INTMAX_C(1000000)> micro;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),                BOOST_RATIO_INTMAX_C(1000)> milli;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),                 BOOST_RATIO_INTMAX_C(100)> centi;
+typedef ratio<BOOST_RATIO_INTMAX_C(1),                  BOOST_RATIO_INTMAX_C(10)> deci;
+typedef ratio<                 BOOST_RATIO_INTMAX_C(10), BOOST_RATIO_INTMAX_C(1)> deca;
+typedef ratio<                BOOST_RATIO_INTMAX_C(100), BOOST_RATIO_INTMAX_C(1)> hecto;
+typedef ratio<               BOOST_RATIO_INTMAX_C(1000), BOOST_RATIO_INTMAX_C(1)> kilo;
+typedef ratio<            BOOST_RATIO_INTMAX_C(1000000), BOOST_RATIO_INTMAX_C(1)> mega;
+typedef ratio<         BOOST_RATIO_INTMAX_C(1000000000), BOOST_RATIO_INTMAX_C(1)> giga;
+typedef ratio<      BOOST_RATIO_INTMAX_C(1000000000000), BOOST_RATIO_INTMAX_C(1)> tera;
+typedef ratio<   BOOST_RATIO_INTMAX_C(1000000000000000), BOOST_RATIO_INTMAX_C(1)> peta;
+typedef ratio<BOOST_RATIO_INTMAX_C(1000000000000000000), BOOST_RATIO_INTMAX_C(1)> exa;
+
+#ifdef BOOST_RATIO_EXTENSIONS
+
+#define BOOST_RATIO_1024 BOOST_RATIO_INTMAX_C(1024)
+
+// convenience IEC typedefs
+typedef ratio<                                                                                     BOOST_RATIO_1024> kibi;
+typedef ratio<                                                                    BOOST_RATIO_1024*BOOST_RATIO_1024> mebi;
+typedef ratio<                                                   BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> gibi;
+typedef ratio<                                  BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> tebi;
+typedef ratio<                 BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> pebi;
+typedef ratio<BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> exbi;
+
+#endif
+}  // namespace boost
+
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/index.html

@@ -0,0 +1,15 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/ratio.html">
+</head>
+<body>
+Automatic redirection failed, please go to 
+<a href="../../doc/html/ratio.html">../../doc/html/ratio.html</a>
+<p>&copy; Copyright 2009-2010 Vicente J. Botet Escrib&aacute;.
+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">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+</body>
+</html>

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/meta/libraries.json

@@ -0,0 +1,18 @@
+{
+  "key": "ratio",
+  "name": "Ratio",
+  "authors": [
+    "Howard Hinnant",
+    "Beman Dawes",
+    "Vicente J. Botet Escriba"
+  ],
+  "maintainers": [
+    "Vicente J. Botet Escriba <vicente.botet -at- wanadoo.fr>"
+  ],
+  "description":
+    "Compile time rational arithmetic. C++11.",
+  "std": [ "proposal" ],    
+  "category": [
+    "Math"
+  ]
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/CMakeLists.txt

@@ -0,0 +1,59 @@
+# Copyright 2019 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+#
+# NOTE: CMake support for Boost.Ratio is currently experimental at best
+#       and this file runs only a subset of the unit tests
+#       (in particular none of the fail tests)
+
+# Attach all our tests to the `tests` target, to enable
+# `cmake --build . --target tests`
+if(NOT TARGET tests)
+  add_custom_target(tests)
+endif()
+
+## unit tests
+
+# list of tests that contain a main function
+set( exec_test_files ratio_ext_pass;ratio_io_pass;ratio_pass )
+file( GLOB_RECURSE test_files *_pass.cpp )
+foreach( file IN LISTS test_files )
+
+    get_filename_component( core_name ${file} NAME_WE )
+    set( test_name boost_ratio-test-${core_name} )
+
+    if( ${core_name} IN_LIST exec_test_files )
+        add_executable( ${test_name} EXCLUDE_FROM_ALL ${file} )
+        add_test( NAME ${test_name} COMMAND ${test_name} )
+    else()
+        # most tests are compile only, so we just need to create an object file
+        # in order to see, if it compiles
+        add_library( ${test_name} STATIC EXCLUDE_FROM_ALL ${file})
+    endif()
+
+    add_dependencies(tests ${test_name})
+
+    target_link_libraries( ${test_name} PUBLIC
+        Boost::ratio
+    )
+
+endforeach()
+
+## examples
+file( GLOB_RECURSE test_files ../example/*.cpp )
+foreach( file IN LISTS test_files )
+
+    get_filename_component( core_name ${file} NAME_WE )
+    set( test_name boost_ratio-example-${core_name} )
+
+    add_executable( ${test_name} EXCLUDE_FROM_ALL ${file} )
+
+    target_link_libraries( ${test_name} PUBLIC
+        Boost::ratio Boost::chrono
+    )
+
+    add_dependencies(tests ${test_name})
+
+    add_test( NAME ${test_name} COMMAND ${test_name} )
+
+endforeach()

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/Jamfile.v2

@@ -0,0 +1,132 @@
+# Boost Ratio Library test Jamfile
+
+# Copyright Beman Dawes 2003, 2006, 2008
+
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
+
+# See library home page at http://www.boost.org/libs/ratio
+
+# uncomment one if the above lines if you build outside the Boost release
+#local BOOST_ROOT = /boost_1_41_0 ;
+#local BOOST_ROOT = c:/cygwin/boost_1_41_0 ;
+
+if ! $(BOOST_ROOT)
+{
+    BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
+}
+
+project
+    : requirements
+        #<os>LINUX:<threading>multi
+        # uncomment the line above if you build outside the Boost release
+        #<include>$(BOOST_ROOT)
+        # uncomment the line above if you build outside the Boost release
+        #<include>../../..
+        <toolset>msvc:<asynch-exceptions>on
+        <define>BOOST_ENABLE_WARNINGS
+        <define>BOOST_RATIO_USES_MPL_ASSERT
+        <define>BOOST_RATIO_VERSION=2
+        <define>BOOST_MPL_NEXT_PRIOR_EXT
+        #<toolset>sun:<define>BOOST_COMMON_TYPE_DONT_USE_TYPEOF
+        #<toolset>sun:<define>BOOST_TYPEOF_EMULATION
+        <toolset>sun:<define>__typeof__=__typeof__ 
+        <warnings>all
+        <toolset>gcc:<cxxflags>-Wextra
+        <toolset>gcc:<cxxflags>-Wno-long-long
+        <toolset>gcc:<cxxflags>-pedantic
+        <toolset>darwin:<cxxflags>-Wextra
+        <toolset>darwin:<cxxflags>-Wno-long-long
+        <toolset>darwin:<cxxflags>-pedantic
+        #<toolset>pathscale:<cxxflags>-Wextra
+        <toolset>pathscale:<cxxflags>-Wno-long-long
+        <toolset>pathscale:<cxxflags>-pedantic
+        <toolset>clang:<cxxflags>-Wextra
+        <toolset>clang:<cxxflags>-pedantic
+        <toolset>clang:<cxxflags>-Wno-long-long
+        #<toolset>gcc-mingw-4.5.0:<cxxflags>-Wno-missing-field-initializers
+        #<toolset>gcc-mingw-4.5.0:<cxxflags>-fdiagnostics-show-option
+        #<toolset>gcc-mingw-4.6.0:<cxxflags>-fdiagnostics-show-option
+        <toolset>msvc:<cxxflags>/wd4127
+# Note: Some of the remarks from the Intel compiler are disabled
+# remark #1418: external function definition with no prior declaration
+# remark #304: access control not specified ("public" by default)
+        <toolset>intel:<cxxflags>-wd304,1418
+    ;
+
+    test-suite "ratio_ratio"
+        :
+        [ compile typedefs_pass.cpp ]
+        [ compile ratio_ratio/ratio_pass.cpp ]
+        [ compile-fail ratio_ratio/ratio1_fail.cpp ]
+        [ compile-fail ratio_ratio/ratio2_fail.cpp ]
+        [ compile-fail ratio_ratio/ratio3_fail.cpp ]
+        [ compile-fail ratio_ratio/ratio4_fail.cpp ]
+        ;
+
+    test-suite "ratio_io"
+        :
+        [ compile-fail ratio_io/ratio_io_fail.cpp ]
+        [ run ratio_io/ratio_io_pass.cpp ]
+        ;
+
+    test-suite "ratio_arithmetic"
+        :
+        [ compile ratio_arithmetic/ratio_add_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_subtract_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_multiply_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_divide_pass.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_add_fail.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_add_2_fail.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_add_3_fail.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_subtract_fail.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_multiply_fail.cpp  ]
+        [ compile-fail ratio_arithmetic/ratio_divide_fail.cpp  ]
+        [ compile ratio_arithmetic/ratio_negate_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_sign_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_abs_pass.cpp  ]
+        [ compile ratio_arithmetic/ratio_power_pass.cpp  ]
+        ;
+
+    test-suite "ratio_comparison"
+        :
+        [ compile ratio_comparison/ratio_equal_pass.cpp  ]
+        [ compile ratio_comparison/ratio_not_equal_pass.cpp  ]
+        [ compile ratio_comparison/ratio_less_pass.cpp  ]
+        [ compile ratio_comparison/ratio_less_equal_pass.cpp  ]
+        [ compile ratio_comparison/ratio_greater_pass.cpp  ]
+        [ compile ratio_comparison/ratio_greater_equal_pass.cpp  ]
+        ;
+
+    test-suite "examples"
+        :
+        [ run ../example/si_physics.cpp ]
+        [ run ../example/display_ex.cpp ]
+        ;
+
+    test-suite "ratio_ext"
+        :
+        [ run ratio_extensions/ratio_ext_pass.cpp  ]
+        [ compile ratio_extensions/mpl_plus_pass.cpp  ]
+        [ compile ratio_extensions/mpl_minus_pass.cpp  ]
+        [ compile ratio_extensions/mpl_times_pass.cpp  ]
+        [ compile ratio_extensions/mpl_divides_pass.cpp  ]
+        [ compile ratio_extensions/mpl_negate_pass.cpp  ]
+        [ compile ratio_extensions/mpl_sign_pass.cpp  ]
+        [ compile ratio_extensions/mpl_abs_pass.cpp  ]
+        [ compile ratio_extensions/mpl_equal_to_pass.cpp  ]
+        [ compile ratio_extensions/mpl_not_equal_to_pass.cpp  ]
+        [ compile ratio_extensions/mpl_less_pass.cpp  ]
+        [ compile ratio_extensions/mpl_less_equal_pass.cpp  ]
+        [ compile ratio_extensions/mpl_greater_pass.cpp  ]
+        [ compile ratio_extensions/mpl_greater_equal_pass.cpp  ]
+        [ compile ratio_extensions/mpl_arithmetic_pass.cpp  ]
+        [ compile ratio_extensions/mpl_comparison_pass.cpp  ]
+        [ compile ratio_extensions/mpl_rational_constant_pass.cpp  ]
+
+        ;
+
+    #test-suite "tickets"
+    #    :
+    #    [ run test_6498_pass.cpp  ]
+    #    ;

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_abs_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_abs
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::ratio_abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio_abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio_abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio_abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_add_2_fail.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+
+
+template <typename R>
+struct numerator;
+
+template <boost::intmax_t N, boost::intmax_t D>
+struct numerator<boost::ratio<N,D> > {
+    static const boost::intmax_t value = N;    
+};
+
+
+BOOST_RATIO_STATIC_ASSERT((
+        numerator<boost::ratio_add<boost::ratio<1,2>,boost::ratio<1,3> > >::value == 1)
+        , NOTHING, ());

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_add_3_fail.cpp

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+
+template <typename T, typename R>
+struct S {
+    T val;
+};
+
+boost::intmax_t func(S<int, boost::ratio<5,6> > const& s) {
+    return s.val*3;    
+}
+
+
+boost::intmax_t test() {
+    return func(
+            S<int, boost::ratio_add<
+                boost::ratio<1,2>,
+                boost::ratio<1,3> 
+            >
+            //~ ::type 
+            >() 
+            );
+}
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_add_fail.cpp

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/integer_traits.hpp>
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+
+typedef boost::ratio<boost::integer_traits<boost::intmax_t>::const_max, 1> R1;
+typedef boost::ratio<1, 1> R2;
+typedef boost::ratio_add<R1, R2>::type RT;
+
+BOOST_RATIO_STATIC_ASSERT(RT::num==boost::integer_traits<boost::intmax_t>::const_max+1, NOTHING, (RT));
+BOOST_RATIO_STATIC_ASSERT(RT::den==1, NOTHING, (RT));

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_add_pass.cpp

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_add
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+  {
+  typedef boost::ratio<0> R1;
+  typedef boost::ratio<0> R2;
+  typedef boost::ratio_add<R1, R2> R;
+  BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+  }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 2 && R::den == 1, NOTHING, ());
+    typedef boost::ratio_add<R, R2> RR;
+    BOOST_RATIO_STATIC_ASSERT(RR::num == 3 && RR::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::ratio_add<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 127970191639601LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::ratio_add<R1, R2>::type RT;
+    }
+
+}
+
+boost::intmax_t func(boost::ratio<5,6> s) {
+    return s.num;
+}
+
+
+boost::intmax_t test_conversion() {
+    return func(
+            boost::ratio_add<
+                boost::ratio<1,2>,
+                boost::ratio<1,3>
+            >
+            ()
+            );
+}
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_divide_fail.cpp

@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_divide
+
+#include <boost/ratio/ratio.hpp>
+
+typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+typedef boost::ratio<1,2> R2;
+typedef boost::ratio_divide<R1, R2>::type RT;

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_divide_pass.cpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_divide
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::ratio_divide<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 630992477165LL && R::den == 127339199162436LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_multiply_fail.cpp

@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_multiply
+
+#include <boost/ratio/ratio.hpp>
+
+typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+typedef boost::ratio<2,1> R2;
+typedef boost::ratio_multiply<R1, R2>::type RT;

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_multiply_pass.cpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_multiply
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::ratio_multiply<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 15519594064236LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_negate_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_negate
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::ratio_negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio_negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio_negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio_negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_power_pass.cpp

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_power
+
+#define BOOST_RATIO_EXTENSIONS
+#include <boost/ratio/ratio.hpp>
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+  {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_power<R1, 1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_power<R1, -1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 2 && R::den == 1, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_power<R1, 0> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio_power<R1, 2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 4, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio_power<R1, 2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 4, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<2, 3> R1;
+    typedef boost::ratio_power<R1, 2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 4 && R::den == 9, NOTHING, ());
+  }
+  {
+    typedef boost::ratio<2, 3> R1;
+    typedef boost::ratio_power<R1, -2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 9 && R::den == 4, NOTHING, ());
+  }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_sign_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_sign
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::ratio_sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 0, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio_sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio_sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio_sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == -1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio_sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == -1, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_subtract_fail.cpp

@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_subtract
+
+#include <boost/ratio/ratio.hpp>
+
+typedef boost::ratio<BOOST_RATIO_INTMAX_C(-0x7FFFFFFFFFFFFFFF), 1> R1;
+typedef boost::ratio<1,1> R2;
+typedef boost::ratio_subtract<R1, R2>::type RT;

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_arithmetic/ratio_subtract_pass.cpp

@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_subtract
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+  {
+  typedef boost::ratio<0> R1;
+  typedef boost::ratio<0> R2;
+  typedef boost::ratio_subtract<R1, R2> R;
+  BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+  }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::ratio_subtract<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -126708206685271LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_equal_pass.cpp

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_equal
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_greater_equal_pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1,BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1,BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_greater_pass.cpp

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_greater<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_less_equal_pass.cpp

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_less_pass.cpp

@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R1;
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R1;
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFELL, 0x7FFFFFFFFFFFFFFDLL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<641981, 1339063> R1;
+    typedef boost::ratio<1291640, 2694141LL> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1291640, 2694141LL> R1;
+    typedef boost::ratio<641981, 1339063> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_less<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_comparison/ratio_not_equal_pass.cpp

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio_not_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_abs_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::abs
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/abs.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::mpl::abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::mpl::abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::mpl::abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::mpl::abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::mpl::abs<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_arithmetic_pass.cpp

@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/arithmetic.hpp>
+
+void test()
+{
+
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_comparison_pass.cpp

@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/comparison.hpp>
+
+void test()
+{
+
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_divides_pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::divides
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/divides.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::mpl::divides<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 630992477165LL && R::den == 127339199162436LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_equal_to_pass.cpp

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::equal_to
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/equal_to.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::equal_to<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_greater_equal_pass.cpp

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/greater_equal.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1,BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1,BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_greater_pass.cpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/greater.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::greater<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_less_equal_pass.cpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/less_equal.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less_equal<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_less_pass.cpp

@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/less.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R1;
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-0x7FFFFFFFFFFFFFFDLL, 0x7FFFFFFFFFFFFFFCLL> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 0x7FFFFFFFFFFFFFFELL> R1;
+    typedef boost::ratio<0x7FFFFFFFFFFFFFFELL, 0x7FFFFFFFFFFFFFFDLL> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<641981, 1339063> R1;
+    typedef boost::ratio<1291640, 2694141LL> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1291640, 2694141LL> R1;
+    typedef boost::ratio<641981, 1339063> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::less<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_minus_pass.cpp

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::minus
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/minus.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::mpl::minus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -126708206685271LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_negate_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::negate
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/negate.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::mpl::negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 0 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::mpl::negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::mpl::negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::mpl::negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::mpl::negate<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_not_equal_to_pass.cpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/not_equal_to.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((!boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, -1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, BOOST_RATIO_INTMAX_T_MAX> R1;
+    typedef boost::ratio<1, -BOOST_RATIO_INTMAX_T_MAX> R2;
+    BOOST_RATIO_STATIC_ASSERT((boost::mpl::not_equal_to<R1, R2>::value), NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_plus_pass.cpp

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::plus
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/plus.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::mpl::int_<1> R2;
+    typedef boost::mpl::plus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 2 && R::den == 1, NOTHING, ());
+    typedef boost::mpl::plus<R, R2> RR;
+    BOOST_RATIO_STATIC_ASSERT(RR::num == 3 && RR::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::mpl::int_<1> R1;
+    typedef boost::ratio<1, 2> R2;
+    typedef boost::mpl::plus<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 3 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 127970191639601LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, 1> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::mpl::int_<0> R3;
+    typedef boost::mpl::plus<R1, R2, R3>::type RT;
+    }
+
+}
+
+boost::intmax_t func(boost::ratio<5,6> s) {
+    return s.num;
+}
+
+
+boost::intmax_t test_conversion() {
+    return func(
+            boost::mpl::plus<
+                boost::ratio<1,2>,
+                boost::ratio<1,3>
+            >
+            ()
+            );
+}
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_rational_constant_pass.cpp

@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/comparison.hpp>
+
+void test()
+{
+
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_sign_pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::sign
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/sign.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+
+    {
+    typedef boost::ratio<0> R1;
+    typedef boost::mpl::sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 0, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::mpl::sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::mpl::sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::mpl::sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == -1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::mpl::sign<R1> R;
+    BOOST_RATIO_STATIC_ASSERT(R::value == -1, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/mpl_times_pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test mpl::times
+
+#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/mpl/times.hpp>
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+void test()
+{
+    {
+    typedef boost::ratio<1, 1> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 1, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<-1, 2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, -2> R1;
+    typedef boost::ratio<1, 1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<-1, 1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<1, 2> R1;
+    typedef boost::ratio<1, -1> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == -1 && R::den == 2, NOTHING, ());
+    }
+    {
+    typedef boost::ratio<56987354, 467584654> R1;
+    typedef boost::ratio<544668, 22145> R2;
+    typedef boost::mpl::times<R1, R2> R;
+    BOOST_RATIO_STATIC_ASSERT(R::num == 15519594064236LL && R::den == 5177331081415LL, NOTHING, ());
+    }
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_extensions/ratio_ext_pass.cpp

@@ -0,0 +1,30 @@
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio:  equivalent ratios convert with BOOST_RATIO_EXTENSIONS
+
+#define BOOST_RATIO_EXTENSIONS
+#include <boost/ratio/ratio.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+boost::intmax_t func(boost::ratio<5,6>  s);
+
+boost::intmax_t func(boost::ratio<5,6>  s) {
+    return s.num;    
+}
+
+void test();
+
+void test() {
+    boost::ratio<10,12> r;
+    BOOST_TEST((
+        func(r)==5
+    ));
+}
+
+int main()
+{
+    test();
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_io/ratio_io_fail.cpp

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio_io.hpp>
+
+//typedef boost::ratio_string<boost::ratio_add<boost::ratio<1,2>, boost::ratio<1,3> >, char> R1;
+typedef boost::ratio_string<int, char> R1;
+
+void test() {
+
+    std::string str = R1::symbol();
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_io/ratio_io_pass.cpp

@@ -0,0 +1,171 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio_add
+
+#define BOOST_RATIO_EXTENSIONS
+#include <boost/ratio/ratio_io.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <climits>
+
+int main()
+{
+
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::atto, char>::prefix() == "atto"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::atto, char>::symbol() == "a"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::femto, char>::prefix() == "femto"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::femto, char>::symbol() == "f"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::pico, char>::prefix() == "pico"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::pico, char>::symbol() == "p"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::nano, char>::prefix() == "nano"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::nano, char>::symbol() == "n"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::micro, char>::prefix() == "micro"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::micro, char>::symbol() == "\xC2\xB5"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::milli, char>::prefix() == "milli"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::milli, char>::symbol() == "m"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::centi, char>::prefix() == "centi"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::centi, char>::symbol() == "c"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::deci, char>::prefix() == "deci"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::deci, char>::symbol() == "d"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::deca, char>::prefix() == "deca"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::deca, char>::symbol() == "da"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::hecto, char>::prefix() == "hecto"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::hecto, char>::symbol() == "h"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::kilo, char>::prefix() == "kilo"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::kilo, char>::symbol() == "k"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::mega, char>::prefix() == "mega"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::mega, char>::symbol() == "M"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::giga, char>::prefix() == "giga"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::giga, char>::symbol() == "G"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::tera, char>::prefix() == "tera"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::tera, char>::symbol() == "T"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::peta, char>::prefix() == "peta"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::peta, char>::symbol() == "P"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::exa, char>::prefix() == "exa"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::exa, char>::symbol() == "E"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::kibi, char>::prefix() == "kibi"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::kibi, char>::symbol() == "Ki"
+        ));
+    }
+    {
+        BOOST_TEST((
+                boost::ratio_string<boost::gibi, char>::prefix() == "gibi"
+        ));
+        BOOST_TEST((
+                boost::ratio_string<boost::gibi, char>::symbol() == "Gi"
+        ));
+    }
+    return boost::report_errors();
+}
+
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_ratio/ratio1_fail.cpp

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio:  The template argument D mus not be zero
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/cstdint.hpp>
+
+void test()
+{
+    const boost::intmax_t t1 = boost::ratio<1, 0>::num;
+    (void)t1;
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_ratio/ratio2_fail.cpp

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio:  the absolute values of the template arguments N and D
+//               must be representable by type intmax_t.
+
+#include <boost/ratio/ratio.hpp>
+#include <cstdint>
+
+void test()
+{
+    const boost::intmax_t t1 = boost::ratio<0x8000000000000000ULL, 1>::num;
+    (void)t1;
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_ratio/ratio3_fail.cpp

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio:  the absolute values of the template arguments N and D
+//               must be representable by type intmax_t.
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/cstdint.hpp>
+
+void test()
+{
+    const boost::intmax_t t1 = boost::ratio<1, 0x8000000000000000ULL>::num;
+    (void)t1;
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_ratio/ratio4_fail.cpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//#define BOOST_RATIO_EXTENSIONS
+
+#include <boost/ratio/ratio.hpp>
+
+boost::intmax_t func(boost::ratio<5,6> const& s) {
+    return s.num;    
+}
+
+boost::intmax_t test() {
+    return func(boost::ratio<10,12>());
+}
+

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_ratio/ratio_pass.cpp

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+//  Copyright 2010 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// test ratio:  The static data members num and den shall have thcommon
+//    divisor of the absolute values of N and D:
+
+#include <boost/ratio/ratio.hpp>
+
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+#define NOTHING ""
+#endif
+
+template <long long N, long long D, long long eN, long long eD>
+void test()
+{
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio<N, D>::num == eN),  NOTHING, (boost::mpl::integral_c<boost::intmax_t,boost::ratio<N, D>::num>));
+    BOOST_RATIO_STATIC_ASSERT((boost::ratio<N, D>::den == eD), NOTHING, (boost::mpl::integral_c<boost::intmax_t,boost::ratio<N, D>::den>));
+}
+
+int main()
+{
+    test<1, 1, 1, 1>();
+    test<1, 10, 1, 10>();
+    test<10, 10, 1, 1>();
+    test<10, 1, 10, 1>();
+    test<12, 4, 3, 1>();
+    test<12, -4, -3, 1>();
+    test<-12, 4, -3, 1>();
+    test<-12, -4, 3, 1>();
+    test<4, 12, 1, 3>();
+    test<4, -12, -1, 3>();
+    test<-4, 12, -1, 3>();
+    test<-4, -12, 1, 3>();
+    test<222, 333, 2, 3>();
+    test<222, -333, -2, 3>();
+    test<-222, 333, -2, 3>();
+    test<-222, -333, 2, 3>();
+    //test<BOOST_RATIO_INTMAX_T_MAX, 127, 72624976668147841LL, 1>();
+    //test<-BOOST_RATIO_INTMAX_T_MAX, 127, -72624976668147841LL, 1>();
+    //test<BOOST_RATIO_INTMAX_T_MAX, -127, -72624976668147841LL, 1>();
+    //test<-BOOST_RATIO_INTMAX_T_MAX, -127, 72624976668147841LL, 1>();
+    //~ test<BOOST_RATIO_INTMAX_T_MAX, 127, BOOST_RATIO_INTMAX_T_MAX, 127>();
+    //~ test<-BOOST_RATIO_INTMAX_T_MAX, 127, -BOOST_RATIO_INTMAX_T_MAX, 127>();
+    //~ test<BOOST_RATIO_INTMAX_T_MAX, -127, -BOOST_RATIO_INTMAX_T_MAX, 127>();
+    //~ test<-BOOST_RATIO_INTMAX_T_MAX, -127, BOOST_RATIO_INTMAX_T_MAX, 127>();
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/ratio_test.cpp

@@ -0,0 +1,36 @@
+//  ratio_test.cpp  ----------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio.hpp>
+#include <iostream>
+
+typedef boost::ratio<5, 3>   five_thirds;       // five_thirds::num == 5, five_thirds::den == 3
+typedef boost::ratio<25, 15> also_five_thirds;  // also_five_thirds::num == 5, also_five_thirds::den == 3
+typedef boost::ratio_divide<five_thirds, also_five_thirds>::type one;  // one::num == 1, one::den == 1
+
+
+typedef boost::ratio_multiply<boost::ratio<5>, boost::giga>::type _5giga;  // _5giga::num == 5000000000, _5giga::den == 1
+typedef boost::ratio_multiply<boost::ratio<5>, boost::nano>::type _5nano;  // _5nano::num == 1, _5nano::den == 200000000
+
+//  Test the case described in library working group issue 948.
+
+typedef boost::ratio<BOOST_RATIO_INTMAX_T_MAX, BOOST_RATIO_INTMAX_T_MAX-16> R1;
+typedef boost::ratio<8, 7> R2;
+typedef boost::ratio_multiply<R1, R2>::type RT;
+
+
+
+int main()
+{
+    typedef boost::ratio<8, BOOST_RATIO_INTMAX_C(0x7FFFFFFFD)> R1;
+    typedef boost::ratio<3, BOOST_RATIO_INTMAX_C(0x7FFFFFFFD)> R2;
+    typedef boost::ratio_subtract<R1, R2>::type RS;
+    std::cout << RS::num << '/' << RS::den << '\n';
+
+  return 0;
+}

externals/vcpkg/buildtrees/boost-ratio/src/ost-1.79.0-f356802fb2.clean/test/test_cmake/CMakeLists.txt

@@ -0,0 +1,40 @@
+# Copyright 2018 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5)
+# NOTE: Individual boost cmake files might require a higher cmake version
+
+project(boost LANGUAGES CXX)
+
+#=== options ===
+
+# Some libraries' cmake files don't work well with this cmake file, e.g. because
+# - they are generally not designed to support the add_subdirectory workflow at all
+# - they define targets with conflicting names (e.g. check)
+# - require some additional (internal or external) dependencies
+#
+# Those libraries can be excluded here
+set(BOOST_RATIO_IGNORE_LIBS callable_traits;hof;compute;gil;hana;yap;safe_numerics;beast CACHE STRING "List of libraries that will be excluded from cmake build")
+
+
+#~~~ options ~~~
+message(STATUS "[Boost] Excluded libs (BOOST_RATIO_IGNORE_LIBS): ${BOOST_RATIO_IGNORE_LIBS}")
+
+# cmake doesn't require autolinking and currently most cmake files don't produce
+# name mangled libraries anyway
+add_definitions(-DBOOST_ALL_NO_LIB)
+enable_testing()
+
+# Detect and process all CMakeLists files that reside in the root folder of a library
+file(GLOB boost_libs_with_cmake_files ../../../../libs/*/CMakeLists.txt)
+
+foreach(cmake_file IN LISTS boost_libs_with_cmake_files)
+
+    get_filename_component(dir ${cmake_file} DIRECTORY)
+    get_filename_component(lib_name ${dir} NAME)
+    if(NOT lib_name IN_LIST BOOST_RATIO_IGNORE_LIBS)
+        add_subdirectory(${dir} ${lib_name})
+    endif()
+
+endforeach()